home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Utilities / PalmLink / developer / palmlink.doc < prev    next >
Text File  |  2000-01-06  |  93KB  |  3,340 lines
  1. TABLE OF CONTENTS
  2.  
  3. palmlink.library/--background--
  4. palmlink.library/DLP_AddSyncLogEntry
  5. palmlink.library/DLP_CleanUpDatabase
  6. palmlink.library/DLP_CloseAllDB
  7. palmlink.library/DLP_CloseDB
  8. palmlink.library/DLP_CountDBEntries
  9. palmlink.library/DLP_CreateDB
  10. palmlink.library/DLP_DeleteCategory
  11. palmlink.library/DLP_DeleteDB
  12. palmlink.library/DLP_DeleteRecord
  13. palmlink.library/DLP_DeleteResource
  14. palmlink.library/DLP_EndOfSync
  15. palmlink.library/DLP_GetDBInfo
  16. palmlink.library/DLP_GetNetSyncInfo
  17. palmlink.library/DLP_GetRecordIDList
  18. palmlink.library/DLP_GetStorageInfo
  19. palmlink.library/DLP_GetSysInfo
  20. palmlink.library/DLP_GetSysTime
  21. palmlink.library/DLP_GetUserInfo
  22. palmlink.library/DLP_MoveCategory
  23. palmlink.library/DLP_OpenConduit
  24. palmlink.library/DLP_OpenDB
  25. palmlink.library/DLP_ReadAppBlock
  26. palmlink.library/DLP_ReadAppPreference
  27. palmlink.library/DLP_ReadNextCatRecord
  28. palmlink.library/DLP_ReadNextModifiedCatRecord
  29. palmlink.library/DLP_ReadRecordByID
  30. palmlink.library/DLP_ReadRecordByIndex
  31. palmlink.library/DLP_ReadResourceByIndex
  32. palmlink.library/DLP_ReadResourceByType
  33. palmlink.library/DLP_ReadSortBlock
  34. palmlink.library/DLP_ResetDBIndex
  35. palmlink.library/DLP_ResetLastSyncPC
  36. palmlink.library/DLP_ResetSyncFlags
  37. palmlink.library/DLP_ResetSystem
  38. palmlink.library/DLP_SetNetSyncInfo
  39. palmlink.library/DLP_SetSysTime
  40. palmlink.library/DLP_SetUserInfo
  41. palmlink.library/DLP_WriteAppBlock
  42. palmlink.library/DLP_WriteAppPreference
  43. palmlink.library/DLP_WriteRecord
  44. palmlink.library/DLP_WriteResource
  45. palmlink.library/DLP_WriteSortBlock
  46. palmlink.library/PL_Accept
  47. palmlink.library/PL_AddRexxHandle
  48. palmlink.library/PL_CloseSocket
  49. palmlink.library/PL_CMPAbort
  50. palmlink.library/PL_CMPInit
  51. palmlink.library/PL_CMPRead
  52. palmlink.library/PL_CMPWakeUp
  53. palmlink.library/PL_Connect
  54. palmlink.library/PL_DeleteRexxHandle
  55. palmlink.library/PL_DLPInit
  56. palmlink.library/PL_DLPRead
  57. palmlink.library/PL_DLPSend
  58. palmlink.library/PL_DLPTstWrite
  59. palmlink.library/PL_DLPWrite
  60. palmlink.library/PL_DLPWriteByte
  61. palmlink.library/PL_DLPWriteLong
  62. palmlink.library/PL_DLPWriteWord
  63. palmlink.library/PL_Explain
  64. palmlink.library/PL_FileAddRecord
  65. palmlink.library/PL_FileAddResorce
  66. palmlink.library/PL_FileClose
  67. palmlink.library/PL_FileGetAppInfo
  68. palmlink.library/PL_FileGetDBInfo
  69. palmlink.library/PL_FileGetSortInfo
  70. palmlink.library/PL_FileInstall
  71. palmlink.library/PL_FileMerge
  72. palmlink.library/PL_FileOpen
  73. palmlink.library/PL_FileReadRecord
  74. palmlink.library/PL_FileReadRecordID
  75. palmlink.library/PL_FileReadResorce
  76. palmlink.library/PL_FileRetrieve
  77. palmlink.library/PL_FileSetAppInfo
  78. palmlink.library/PL_FileSetDBInfo
  79. palmlink.library/PL_FileSetSortInfo
  80. palmlink.library/PL_FileUsedID
  81. palmlink.library/PL_FindRexxHandle
  82. palmlink.library/PL_GetBaudRate
  83. palmlink.library/PL_LastError
  84. palmlink.library/PL_OpenSocket
  85. palmlink.library/PL_PADPRead
  86. palmlink.library/PL_PADPWrite
  87. palmlink.library/PL_RawRead
  88. palmlink.library/PL_RawSetRate
  89. palmlink.library/PL_RawWrite
  90. palmlink.library/PL_Read
  91. palmlink.library/PL_SLPRead
  92. palmlink.library/PL_SLPWrite
  93. palmlink.library/PL_Tickle
  94. palmlink.library/PL_Write
  95.  
  96. palmlink.library/--background--
  97.  
  98.    NAME
  99.         palmlink.library
  100.  
  101.    DESCRIPTION
  102.         This library provides a connection to 3Com's Palm PDA with PalmOS
  103.         2.0 or later. With appropriate software, you are now able to use
  104.         the HotSync feature on your Amiga as well.
  105.  
  106.    REQUIREMENTS
  107.         PalmLink requires at least AmigaOS V2.04, a 68020 processor, and
  108.         a Palm organizer connected to any serial port of the Amiga. An
  109.         68000 version is also available.
  110.  
  111.         The palmlink.library requires at least 8192 byte of Stack, so
  112.         be prepared! Currently, you must call all function from the same
  113.         task that opened the socket.
  114.  
  115.    CONSTRUCTION
  116.         The lowest layer of PalmLink is the serial device itself. It is
  117.         controlled by all PL_RAW commands.
  118.  
  119.         Basing on the serial layer, the SLP (Serial Link Protocol) handles
  120.         the source and destination ID, and the message type. The maximum
  121.         size of SLP messages is 1024 byte.
  122.  
  123.         The PADP (Packet Assembly Disassembly Protocol) splits or joins
  124.         the data packets, respectively. It also attaches a transaction
  125.         ID so the packets can be joined properly. Anyhow, even the PADP
  126.         data packages are limited to about 65536 byte.
  127.  
  128.         The CMP (Connection Management Protocol) controls the connection
  129.         between the Palm Pilot and the Amiga, as e.g. the baud rate used.
  130.  
  131.         Until here, the client usually does not need to call any functions.
  132.         The main API of the library consists of connection and data transfer
  133.         functions. They are based on BSD socket like functions, though they
  134.         are quite 'Amigized'.
  135.  
  136.         A high level protocol is the SYSPKT protocol. It is used for
  137.         debugging purposes. Currently it is not implemented to palmlink.
  138.         I will only implement it upon significant request.
  139.  
  140.         The client will use the DLP (Desktop Link Protocol) in most cases.
  141.         With this protocol, the Pilot's data base can be accessed and
  142.         manipulated. Basing on this, the client can do a backup of all
  143.         data as well as 'HotSync' the Scheduler, ToDo list, and other
  144.         data bases.
  145.  
  146.         Additionally, there are some functions that provide access to '.prc'
  147.         and '.pdb' files as data bases.
  148.  
  149.         For ARexx library programmers, basic handle managment is provided.
  150.  
  151.    BUGS
  152.         Currently, palmlink calls its own functions by a direct call. Thus,
  153.         patching library functions does not show any effect. Please don't
  154.         patch anything until further notice.
  155.  
  156.         The provided pointers are *not* checked against NULL yet. I strongly
  157.         suggest to use Enforcer during development.
  158.  
  159.         PL_Connect() still does not work. I'm currently evaluating this bug.
  160.  
  161.    IMPORTANT
  162.         · Make sure that the stack is large enough (8192 byte at least)
  163.         · Currently, you MUST use all functions within the same task that
  164.           opened the socket to the Palm organizer.
  165.         · Do not manipulate READ ONLY fields!
  166.         · Do not use PRIVATE stuff!
  167.         · Do not assume a special value for TRUE. TRUE is anything except 0.
  168.  
  169.    COPYRIGHT
  170.         The palmlink.library is Copyright (C) 1998-99 by Richard Körber.
  171.         All rights reserved. Please read the main guide for further
  172.         information and the copyright note.
  173.  
  174.         palmlink.library is MailWare. You don't need to pay any fees, though
  175.         you must send me an e-mail if you use it.
  176.  
  177.         If it is used in commercial software (ShareWare is commercial as
  178.         well), you must provide me with a full featured and registered
  179.         release of your software, along with all future updates, as long
  180.         as you use the palmlink.library, and without any charge.
  181.  
  182.         E-Mail:  richard.koerber@koeln.netsurf.de
  183.                  shred@eratosthenes.starfleet.de
  184.  
  185.         WWW:     http://shredzone.home.pages.de/
  186.  
  187.    TRADEMARKS
  188.         Palm Pilot, Palm III and PalmOS are trademarks of 3Com.
  189.         3Com and HotSync are registered trademarks of 3Com.
  190.  
  191. palmlink.library/DLP_AddSyncLogEntry
  192.  
  193.    NAME
  194.         DLP_AddSyncLogEntry - Add an entry to the HotSync log
  195.  
  196.    SYNOPSIS
  197.         Success = DLP_AddSyncLogEntry(Socket,Entry)
  198.           D0.l                         A0.l  A1.l
  199.  
  200.         int DLP_AddSyncLogEntry(APTR,STRPTR);
  201.  
  202.    FUNCTION
  203.         Add an entry to the HotSync log. The user can read the last HotSync
  204.         log with the HotSync tool of the Palm Pilot.
  205.  
  206.    INPUTS
  207.         Socket        -- (APTR) Socket
  208.         Entry         -- (STRPTR) String to be added
  209.  
  210.    RESULT
  211.         Success       -- (int) TRUE: Entry has been added
  212.  
  213.    NOTE
  214.  
  215.    BUGS
  216.  
  217.    SEE ALSO
  218.  
  219.  
  220. palmlink.library/DLP_CleanUpDatabase
  221.  
  222.    NAME
  223.         DLP_CleanUpDatabase - Clean up the database
  224.  
  225.    SYNOPSIS
  226.         Success = DLP_CleanUpDatabase(Socket,DBHandle)
  227.           D0.l                         A0.l    D0.l
  228.  
  229.         int DLP_CleanUpDatabase(APTR,LONG);
  230.  
  231.    FUNCTION
  232.         Clean up the database.
  233.  
  234.    INPUTS
  235.         Socket        -- (APTR) Socket
  236.         DBHandle      -- (LONG) Handle of the database to be cleaned.
  237.  
  238.    RESULT
  239.         Success       -- (int) TRUE: this call succeeded. FALSE: an
  240.                 error occured (see PL_LastError()).
  241.  
  242.    NOTE
  243.  
  244.    BUGS
  245.  
  246.    SEE ALSO
  247.  
  248.  
  249. palmlink.library/DLP_CloseAllDB
  250.  
  251.    NAME
  252.         DLP_CloseAllDB - Close all opened databases
  253.  
  254.    SYNOPSIS
  255.         Success = DLP_CloseAllDB(Socket)
  256.           D0.l                    A0.l
  257.  
  258.         int DLP_CloseAllDB(APTR);
  259.  
  260.    FUNCTION
  261.         Closes all databases previously opened.
  262.  
  263.    INPUTS
  264.         Socket        -- (APTR) Socket
  265.  
  266.    RESULT
  267.         Success       -- (int) TRUE: all DB have been closed successfully
  268.  
  269.    NOTE
  270.  
  271.    BUGS
  272.  
  273.    SEE ALSO
  274.         DLP_CloseDB()
  275.  
  276.  
  277. palmlink.library/DLP_CloseDB
  278.  
  279.    NAME
  280.         DLP_CloseDB - Close a database
  281.  
  282.    SYNOPSIS
  283.         Success = DLP_CloseDB(Socket,DBHandle)
  284.           D0.l                 A0.l    D0.l
  285.  
  286.         int DLP_CloseDB(APTR,LONG);
  287.  
  288.    FUNCTION
  289.         Close a database.
  290.  
  291.    INPUTS
  292.         Socket        -- (APTR) Socket
  293.         DBHandle      -- (LONG) Handle of the database to close
  294.  
  295.    RESULT
  296.         Success       -- (int) TRUE: DB has been closed successfully
  297.  
  298.    NOTE
  299.  
  300.    BUGS
  301.  
  302.    SEE ALSO
  303.         DLP_OpenDB(), DLP_CreateDB(), DLP_DeleteDB(), DLP_CloseAllDB()
  304.  
  305.  
  306. palmlink.library/DLP_CountDBEntries
  307.  
  308.    NAME
  309.         DLP_CountDBEntries - Count the entries of a database
  310.  
  311.    SYNOPSIS
  312.         Number = DLP_CountDBEntries(Socket,DBHandle)
  313.          D0.l                        A0.l    D0.l
  314.  
  315.         LONG DLP_CountDBEntries(APTR,LONG);
  316.  
  317.    FUNCTION
  318.         Count the number of entries of a database. Use this function e.g.
  319.         if you want to read all entries of the database.
  320.  
  321.    INPUTS
  322.         Socket        -- (APTR) Socket
  323.         DBHandle      -- (LONG) Handle of the database to count
  324.  
  325.    RESULT
  326.         Number        -- (LONG) Number of entries, or -1 if an error
  327.                 occured (see PL_LastError()).
  328.  
  329.    NOTE
  330.  
  331.    BUGS
  332.  
  333.    SEE ALSO
  334.  
  335.  
  336. palmlink.library/DLP_CreateDB
  337.  
  338.    NAME
  339.         DLP_CreateDB - Create a new database
  340.  
  341.    SYNOPSIS
  342.         DBHandle = DLP_CreateDB(Socket,CardNo,Creator,Type,Flags,Version,Name)
  343.           D0.l                   A0.l   D0.b   D1.l   D2.l  D3.w  D4.w   A1.l
  344.  
  345.         LONG DLP_CreateDB(APTR,UBYTE,ULONG,ULONG,UWORD,UWORD,STRPTR);
  346.  
  347.    FUNCTION
  348.         Create a new database. The database handle is returned.
  349.  
  350.    INPUTS
  351.         Socket        -- (APTR) Socket
  352.         CardNo        -- (UBYTE) Card number of the database (usually 0)
  353.         Creator       -- (ULONG) ID of the DB creator. For own developments,
  354.                 you must register an ID from 3Com (see their web page).
  355.         Type          -- (ULONG) Type ID of the DB.
  356.         Flags         -- (UWORD) Flags (see includes)
  357.         Version       -- (UWORD) Version of the database
  358.         Name          -- (STRPTR) Name of the database to create
  359.  
  360.    RESULT
  361.         DBHandle      -- (LONG) Handle of the created data base, or -1
  362.                 if an error occured (see PL_LastError()).
  363.  
  364.    NOTE
  365.  
  366.    BUGS
  367.  
  368.    SEE ALSO
  369.         DLP_OpenDB(), DLP_DeleteDB(), DLP_CloseDB()
  370.  
  371.  
  372. palmlink.library/DLP_DeleteCategory
  373.  
  374.    NAME
  375.         DLP_DeleteCategory - Delete a record category from the database
  376.  
  377.    SYNOPSIS
  378.         Success = DLP_DeleteCategory(Socket,DBHandle,CatID)
  379.           D0.l                        A0.l    D0.l    D1.b
  380.  
  381.         int DLP_DeleteCategory(APTR,ULONG,BOOL);
  382.  
  383.    FUNCTION
  384.         Delete a record category from the database.
  385.  
  386.    INPUTS
  387.         Socket        -- (APTR) Socket
  388.         DBHandle      -- (LONG) Database handle
  389.         CatID         -- (UBYTE) Category ID to delete
  390.  
  391.    RESULT
  392.         Success       -- (int) TRUE: Category has been deleted.
  393.  
  394.    NOTE
  395.         This function requires PalmOS 2.0 or higher. There is workaround
  396.         for OS 1.0, but since it is quite outdated, I see no reason to
  397.         implement it. If you require it, please get in contact with me.
  398.  
  399.    BUGS
  400.  
  401.    SEE ALSO
  402.  
  403.  
  404. palmlink.library/DLP_DeleteDB
  405.  
  406.    NAME
  407.         DLP_DeleteDB - Delete a database
  408.  
  409.    SYNOPSIS
  410.         Success = DLP_DeleteDB(Socket,CardNo,Name)
  411.           D0.l                  A0.l   D0.b  A1.l
  412.  
  413.         int DLP_DeleteDB(APTR,UBYTE,STRPTR);
  414.  
  415.    FUNCTION
  416.         Delete a database.
  417.  
  418.    INPUTS
  419.         Socket        -- (APTR) Socket
  420.         CardNo        -- (UBYTE) Card number where the database is stored
  421.         Name          -- (STRPTR) Name of the database to be deleted
  422.  
  423.    RESULT
  424.         Success       -- (int) TRUE: DB has been deleted successfully
  425.  
  426.    NOTE
  427.  
  428.    BUGS
  429.  
  430.    SEE ALSO
  431.         DLP_OpenDB(), DLP_CreateDB(), DLP_CloseDB()
  432.  
  433.  
  434. palmlink.library/DLP_DeleteRecord
  435.  
  436.    NAME
  437.         DLP_DeleteRecord - Delete a record from the database
  438.  
  439.    SYNOPSIS
  440.         Success = DLP_DeleteRecord(Socket,DBHandle,All,ID)
  441.           D0.l                      A0.l   D0.l    D1.b D2.l
  442.  
  443.         int DLP_DeleteRecord(APTR,ULONG,BOOL,ULONG);
  444.  
  445.    FUNCTION
  446.         Delete a record from the database.
  447.  
  448.    INPUTS
  449.         Socket        -- (APTR) Socket
  450.         DBHandle      -- (LONG) Database handle
  451.         All           -- (BOOL) True: delete *all* records of this database
  452.         ID            -- (ULONG) Record ID to delete
  453.  
  454.    RESULT
  455.         Success       -- (int) TRUE: Record has been deleted.
  456.  
  457.    NOTE
  458.  
  459.    BUGS
  460.  
  461.    SEE ALSO
  462.  
  463.  
  464. palmlink.library/DLP_DeleteResource
  465.  
  466.    NAME
  467.         DLP_DeleteResource - Delete a resource from the database
  468.  
  469.    SYNOPSIS
  470.         Success = DLP_DeleteResource(Socket,DBHandle,All,Type,ID)
  471.           D0.l                        A0.l   D0.l    D1.b D2.l D3.w
  472.  
  473.         int DLP_DeleteResource(APTR,ULONG,BOOL,ULONG,UWORD);
  474.  
  475.    FUNCTION
  476.         Delete a resource from the database.
  477.  
  478.    INPUTS
  479.         Socket        -- (APTR) Socket
  480.         DBHandle      -- (LONG) Database handle
  481.         All           -- (BOOL) True: delete *all* resources of this database
  482.         Type          -- (ULONG) Resource Type
  483.         ID            -- (ULONG) Record ID
  484.  
  485.    RESULT
  486.         Success       -- (int) TRUE: Resource has been deleted.
  487.  
  488.    NOTE
  489.  
  490.    BUGS
  491.  
  492.    SEE ALSO
  493.  
  494.  
  495. palmlink.library/DLP_EndOfSync
  496.  
  497.    NAME
  498.         DLP_EndOfSync - Terminate all database accesses
  499.  
  500.    SYNOPSIS
  501.         Success = DLP_EndOfSync(Socket,Status)
  502.           D0.l                   A0.l   D0.w
  503.  
  504.         int DLP_EndOfSync(APTR,UWORD);
  505.  
  506.    FUNCTION
  507.         Closes the Pilot database. After you called this function, you
  508.         should close the connection.
  509.  
  510.         *NEVER* forget to call DLP_EndOfSync() when you called
  511.         DLP_OpenConduit(). PalmLink won't do this for you.
  512.  
  513.    INPUTS
  514.         Socket        -- (APTR) Socket
  515.         Status        -- (UWORD) Status code
  516.  
  517.    RESULT
  518.         Success       -- (int) TRUE: this call succeeded. FALSE: an
  519.                 error occured (see PL_LastError()).
  520.  
  521.    NOTE
  522.  
  523.    BUGS
  524.  
  525.    SEE ALSO
  526.         DLP_OpenConduit()
  527.  
  528.  
  529. palmlink.library/DLP_GetDBInfo
  530.  
  531.    NAME
  532.         DLP_GetDBInfo - Get information about the database
  533.  
  534.    SYNOPSIS
  535.         Success = DLP_GetDBInfo(Socket,CardNo,Flags,Index,Info)
  536.           D0.l                   A0.l   D0.b   D1.b  D2.w A1.l
  537.  
  538.         int DLP_GetDBInfo(APTR,UBYTE,UBYTE,UWORD,struct DLP_DBInfo *);
  539.  
  540.    FUNCTION
  541.         The passed DLP_DBInfo structure is filled with information
  542.         about the database with the number provided in Start.
  543.  
  544.    INPUTS
  545.         Socket        -- (APTR) Socket
  546.         CardNo        -- (UBYTE) Card to select (usually 0)
  547.         Flags         -- (UBYTE) Access flags (RAM or ROM), see
  548.                 include file.
  549.         Index         -- (UWORD) Database number to get information
  550.                 about. Start with 0, then proceed with Info.Index+1
  551.                 of each returned data base.
  552.         Info          -- (struct DLP_DBInfo *) DBInfo structure
  553.                 to be filled
  554.  
  555.    RESULT
  556.         Success       -- (int) TRUE: Information has been read.
  557.  
  558.    NOTE
  559.  
  560.    BUGS
  561.  
  562.    SEE ALSO
  563.  
  564.  
  565. palmlink.library/DLP_GetNetSyncInfo
  566.  
  567.    NAME
  568.         DLP_GetNetSyncInfo - Get information about net sync
  569.  
  570.    SYNOPSIS
  571.         Success = DLP_GetNetSyncInfo(Socket,NetSync)
  572.           D0.l                        A0.l   A1.l
  573.  
  574.         int DLP_GetNetSyncInfo(APTR,struct DLP_NetSyncInfo *);
  575.  
  576.    FUNCTION
  577.         Get information about net sync into the DLP_NetSyncInfo structure.
  578.  
  579.    INPUTS
  580.         Socket        -- (APTR) Socket
  581.         NetSync       -- (struct DLP_NetSyncInfo *) Buffer space for the
  582.                 NetSync structure.
  583.  
  584.    RESULT
  585.         Success       -- (int) TRUE: NetSyncInfo has been get.
  586.  
  587.    NOTE
  588.         This function requires PalmOS 2.0 or higher. There is workaround
  589.         for OS 1.0, but since it is quite outdated, I see no reason to
  590.         implement it. If you require it, please get in contact with me.
  591.  
  592.    BUGS
  593.  
  594.    SEE ALSO
  595.         DLP_SetNetSyncInfo()
  596.  
  597.  
  598. palmlink.library/DLP_GetRecordIDList
  599.  
  600.    NAME
  601.         DLP_GetRecordIDList - Get a list of all record IDs of this database
  602.  
  603.    SYNOPSIS
  604.         Number = DLP_GetRecordIDList(Socket,DBHandle,Sort,Start,Max,IDs)
  605.          D0.l                         A0.l    D0.l   D1.w D2.w  D3.w A1.l
  606.  
  607.         LONG DLP_GetRecordIDList(APTR,LONG,BOOL,UWORD,UWORD,ULONG *);
  608.  
  609.    FUNCTION
  610.         Get a list of all record IDs of this database.
  611.  
  612.    INPUTS
  613.         Socket        -- (APTR) Socket
  614.         DBHandle      -- (LONG) Database handle
  615.         Sort          -- (BOOL) The list is sorted
  616.         Start         -- (UWORD) Start record index
  617.         Max           -- (UWORD) Maximum number of entries that fit into
  618.                 the ID table
  619.         IDs           -- (ULONG *) ID table that will contain the record
  620.                 IDs after this call
  621.  
  622.    RESULT
  623.         Number        -- (LONG) Number of IDs that were written into the
  624.                 table, or -1 on error.
  625.  
  626.    NOTE
  627.  
  628.    BUGS
  629.  
  630.    SEE ALSO
  631.  
  632.  
  633. palmlink.library/DLP_GetStorageInfo
  634.  
  635.    NAME
  636.         DLP_GetStorageInfo - Get information about Pilot's memory
  637.  
  638.    SYNOPSIS
  639.         Success = DLP_GetStorageInfo(Socket,CardNo,Info)
  640.           D0.l                        A0.l   D0.b  A1.l
  641.  
  642.         int DLP_GetStorageInfo(APTR,UBYTE,struct DLP_StorageInfo *);
  643.  
  644.    FUNCTION
  645.         The passed DLP_StorageInfo structure is filled with information
  646.         about the Pilot's built-in memory card.
  647.  
  648.    INPUTS
  649.         Socket        -- (APTR) Socket
  650.         CardNo        -- (UBYTE) Card Nr. to be read. Start with 0, then
  651.                 iterate with DLP_StorageInfo.cardNo+1.
  652.         Info          -- (struct DLP_StorageInfo *) StorageInfo structure
  653.                 to be filled
  654.  
  655.    RESULT
  656.         Success       -- (int) TRUE: Information has been read.
  657.  
  658.    NOTE
  659.  
  660.    BUGS
  661.  
  662.    SEE ALSO
  663.  
  664.  
  665. palmlink.library/DLP_GetSysInfo
  666.  
  667.    NAME
  668.         DLP_GetSysInfo - Get information about the Pilot
  669.  
  670.    SYNOPSIS
  671.         Success = DLP_GetSysInfo(Socket,Info)
  672.           D0.l                    A0.l  A1.l
  673.  
  674.         int DLP_GetSysInfo(APTR,struct DLP_SysInfo *);
  675.  
  676.    FUNCTION
  677.         The passed DLP_SysInfo structure is filled with information
  678.         about the Pilot's built-in memory cards.
  679.  
  680.    INPUTS
  681.         Socket        -- (APTR) Socket
  682.         Info          -- (struct DLP_SysInfo *) SysInfo structure
  683.                 to be filled
  684.  
  685.    RESULT
  686.         Success       -- (int) TRUE: Information has been read.
  687.  
  688.    NOTE
  689.  
  690.    BUGS
  691.  
  692.    SEE ALSO
  693.  
  694.  
  695. palmlink.library/DLP_GetSysTime
  696.  
  697.    NAME
  698.         DLP_GetSysTime - Get the Pilot system time
  699.  
  700.    SYNOPSIS
  701.         Success = DLP_GetSysTime(Socket,Time)
  702.           D0.l                    A0.l  A1.l
  703.  
  704.         int DLP_GetSysTime(APTR,struct DLP_SysTime *);
  705.  
  706.    FUNCTION
  707.         The passed DLP_SysTime structure is filled with the current
  708.         time of the Pilot's internal clock.
  709.  
  710.    INPUTS
  711.         Socket        -- (APTR) Socket
  712.         Time          -- (struct DLP_SysTime *) Time structure to be filled
  713.  
  714.    RESULT
  715.         Success       -- (int) TRUE: Time has been read.
  716.  
  717.    NOTE
  718.  
  719.    BUGS
  720.  
  721.    SEE ALSO
  722.         DLP_SetSysTime()
  723.  
  724.  
  725. palmlink.library/DLP_GetUserInfo
  726.  
  727.    NAME
  728.         DLP_GetUserInfo - Get information about the Pilot user
  729.  
  730.    SYNOPSIS
  731.         Success = DLP_GetUserInfo(Socket,User)
  732.           D0.l                     A0.l  A1.l
  733.  
  734.         int DLP_GetUserInfo(APTR,struct DLP_UserInfo *);
  735.  
  736.    FUNCTION
  737.         Get information about the Pilot user (most probably you ;-)
  738.         into the DLP_UserInfo structure.
  739.  
  740.    INPUTS
  741.         Socket        -- (APTR) Socket
  742.         User          -- (struct DLP_UserInfo *) Buffer space for
  743.                 the UserInfo.
  744.  
  745.    RESULT
  746.         Success       -- (int) TRUE: UserInfo has been get.
  747.  
  748.    NOTE
  749.  
  750.    BUGS
  751.  
  752.    SEE ALSO
  753.         DLP_SetUserInfo()
  754.  
  755.  
  756. palmlink.library/DLP_MoveCategory
  757.  
  758.    NAME
  759.         DLP_MoveCategory - Change a record category ID
  760.  
  761.    SYNOPSIS
  762.         Success = DLP_MoveCategory(Socket,DBHandle,OldID,NewID)
  763.          D0.l                       A0.l    D0.l    D1.b  D2.b
  764.  
  765.         int DLP_MoveCategory(APTR,LONG,UBYTE,UBYTE);
  766.  
  767.    FUNCTION
  768.         Changes a record cateogry ID of the selected database to the new
  769.         ID.
  770.  
  771.    INPUTS
  772.         Socket        -- (APTR) Socket
  773.         DBHandle      -- (LONG) Handle of the database
  774.         OldID         -- (UBYTE) Old record category ID
  775.         NewID         -- (UBYTE) New record category ID
  776.  
  777.    RESULT
  778.         Success       -- (int) TRUE: changed successfully
  779.  
  780.    NOTE
  781.  
  782.    BUGS
  783.  
  784.    SEE ALSO
  785.  
  786.  
  787. palmlink.library/DLP_OpenConduit
  788.  
  789.    NAME
  790.         DLP_OpenConduit - Initialize a database access
  791.  
  792.    SYNOPSIS
  793.         Success = DLP_OpenConduit(Socket)
  794.           D0.l                     A0.l
  795.  
  796.         int DLP_OpenConduit(APTR);
  797.  
  798.    FUNCTION
  799.         Open the Pilot database for access. You must call this function
  800.         once, before you call any other DLP_* function.
  801.  
  802.    INPUTS
  803.         Socket        -- (APTR) Socket
  804.  
  805.    RESULT
  806.         Success       -- (int) FALSE: The Conduit couldn't be opened
  807.                 (see PL_LastError()).
  808.  
  809.    NOTE
  810.  
  811.    BUGS
  812.  
  813.    SEE ALSO
  814.         DLP_EndOfSync()
  815.  
  816.  
  817. palmlink.library/DLP_OpenDB
  818.  
  819.    NAME
  820.         DLP_OpenDB - Open an existing database
  821.  
  822.    SYNOPSIS
  823.         DBHandle = DLP_OpenDB(Socket,CardNo,Mode,Name)
  824.           D0.l                 A0.l   D0.b  D1.b A1.l
  825.  
  826.         LONG DLP_OpenDB(APTR,UBYTE,UBYTE,STRPTR);
  827.  
  828.    FUNCTION
  829.         Open an existing database with the name Name and mode Mode. The
  830.         database handle is returned.
  831.  
  832.    INPUTS
  833.         Socket        -- (APTR) Socket
  834.         CardNo        -- (UBYTE) Card number of the database (usually 0)
  835.         Mode          -- (UBYTE) Access mode (see includes)
  836.         Name          -- (STRPTR) Name of the database to open
  837.  
  838.    RESULT
  839.         DBHandle      -- (LONG) Handle of the opened data base, or -1
  840.                 if an error occured (see PL_LastError()).
  841.  
  842.    NOTE
  843.  
  844.    BUGS
  845.  
  846.    SEE ALSO
  847.         DLP_CreateDB(), DLP_DeleteDB(), DLP_CloseDB()
  848.  
  849.  
  850. palmlink.library/DLP_ReadAppBlock
  851.  
  852.    NAME
  853.         DLP_ReadAppBlock - Read an application block
  854.  
  855.    SYNOPSIS
  856.         Length = DLP_ReadAppBlock(Socket,DBHandle,Offset,Buffer,Length)
  857.           D0.l                     A0.l    D0.l    D1.w   A1.l   D2.w
  858.  
  859.         LONG DLP_ReadAppBlock(APTR,LONG,UWORD,APTR,UWORD);
  860.  
  861.    FUNCTION
  862.         Read the application block of the database.
  863.  
  864.    INPUTS
  865.         Socket        -- (APTR) Socket
  866.         DBHandle      -- (LONG) Database handle
  867.         Offset        -- (UWORD) Offset into the application block
  868.         Buffer        -- (APTR) Buffer for the application block
  869.         Length        -- (UWORD) Length of the buffer. As you see, the maximum
  870.                 size is 65535 byte.
  871.  
  872.    RESULT
  873.         Length        -- (LONG) AppBlock bytes that were really read, or -1 if
  874.                 an error occured.
  875.  
  876.    NOTE
  877.  
  878.    BUGS
  879.  
  880.    SEE ALSO
  881.  
  882.  
  883. palmlink.library/DLP_ReadAppPreference
  884.  
  885.    NAME
  886.         DLP_ReadAppPreference - Read the preference of an application
  887.  
  888.    SYNOPSIS
  889.         Length = DLP_ReadAppPreference(Socket,Creator,ID,Saved,MaxSize,Buffer,Size,Version)
  890.          D0.l                           A0.l   D0.l  D1.w D2.w  D3.w    A1.l  A2.l   A3.l
  891.  
  892.         LONG DLP_ReadAppPreference(APTR,ULONG,UWORD,BOOL,UWORD,APTR,UWORD *,UWORD *);
  893.  
  894.    FUNCTION
  895.         Read the preferences of an application. You can choose between the
  896.         saved and the temporary version of the preference.
  897.  
  898.    INPUTS
  899.         Socket        -- (APTR) Socket
  900.         Creator       -- (ULONG) Creator of the application
  901.         ID            -- (UWORD) ID number of the preference (lets an
  902.                 application have multiple preferences)
  903.         Saved         -- (BOOL) TRUE: use the saved preferences, FALSE: use
  904.                 the current preferences.
  905.         MaxSize       -- (UWORD) Size of the buffer
  906.         Buffer        -- (APTR) Buffer where the preferences are stored
  907.         Size          -- (UWORD *) If a pointer is provided, the size of the
  908.                 preference block is stored there. You may provide NULL.
  909.         Version       -- (UWORD *) If a pointer is provided, the version of
  910.                 the preference block is stored there. You may provide NULL.
  911.  
  912.    RESULT
  913.         Length        -- (LONG) Number of bytes that were really read, or -1
  914.                 if an error occured.
  915.  
  916.    NOTE
  917.         This function requires PalmOS 2.0 or higher. There is workaround
  918.         for OS 1.0, but since it is quite outdated, I see no reason to
  919.         implement it. If you require it, please get in contact with me.
  920.  
  921.    BUGS
  922.  
  923.    SEE ALSO
  924.  
  925.  
  926. palmlink.library/DLP_ReadNextCatRecord
  927.  
  928.    NAME
  929.         DLP_ReadNextCatRecord - Read the next record of a category
  930.  
  931.    SYNOPSIS
  932.         Length = DLP_ReadNextCatRecord(Socket,DBHandle,Cat,Buffer,ID,Index,Size,Attr)
  933.           D0.l                          A0.l    D0.l  D1.b  A1.l A2.l A3.l D2.l D3.l
  934.  
  935.         LONG DLP_ReadNextCatRecord(APTR,ULONG,UBYTE,APTR,ULONG *,UWORD *,UWORD *,UBYTE *);
  936.  
  937.    FUNCTION
  938.         Read the next record of a given category.
  939.  
  940.    INPUTS
  941.         Socket        -- (APTR) Socket
  942.         DBHandle      -- (LONG) Database handle
  943.         Cat           -- (UBYTE) Category ID
  944.         Buffer        -- (APTR) Buffer for the record. The buffer must have
  945.                 a sufficient size of 65535 byte.
  946.         ID            -- (ULONG *) If a pointer is provided, the record ID
  947.                 is copied there. You may provide NULL.
  948.         Index         -- (UWORD *) If a pointer is provided, the record index
  949.                 is copied there. You may provide NULL.
  950.         Size          -- (UWORD *) If a pointer is provided, the UWORD is filled
  951.                 with the size of this resource. You may provide NULL.
  952.                 Assembler users watch out: this is a pointer in a data register!
  953.         Attr          -- (UBYTE *) If a pointer is provided, the UBYTE is filled
  954.                 with the record attributes. You may provide NULL.
  955.                 Assembler users watch out: this is a pointer in a data register!
  956.  
  957.    RESULT
  958.         Length        -- (LONG) Record bytes that were really read, or -1 if
  959.                 an error occured.
  960.  
  961.    NOTE
  962.         This function requires PalmOS 2.0 or higher. There is workaround
  963.         for OS 1.0, but since it is quite outdated, I see no reason to
  964.         implement it. If you require it, please get in contact with me.
  965.  
  966.    BUGS
  967.  
  968.    SEE ALSO
  969.  
  970.  
  971. palmlink.library/DLP_ReadNextModifiedCatRecord
  972.  
  973.    NAME
  974.         DLP_ReadNextModifiedCatRecord - Read the next modified record of a category
  975.  
  976.    SYNOPSIS
  977.         Length = DLP_ReadNextModifiedCatRecord(Socket,DBHandle,Cat,Buffer,ID,Index,Size,Attr)
  978.           D0.l                                  A0.l    D0.l  D1.b  A1.l A2.l A3.l D2.l D3.l
  979.  
  980.         LONG DLP_ReadNextModifiedCatRecord(APTR,ULONG,UBYTE,APTR,ULONG *,UWORD *,UWORD *,UBYTE *);
  981.  
  982.    FUNCTION
  983.         Read the next modified record of a given category.
  984.  
  985.    INPUTS
  986.         Socket        -- (APTR) Socket
  987.         DBHandle      -- (LONG) Database handle
  988.         Cat           -- (UBYTE) Category ID
  989.         Buffer        -- (APTR) Buffer for the record. The buffer must have
  990.                 a sufficient size of 65535 byte.
  991.         ID            -- (ULONG *) If a pointer is provided, the record ID
  992.                 is copied there. You may provide NULL.
  993.         Index         -- (UWORD *) If a pointer is provided, the record index
  994.                 is copied there. You may provide NULL.
  995.         Size          -- (UWORD *) If a pointer is provided, the UWORD is filled
  996.                 with the size of this resource. You may provide NULL.
  997.                 Assembler users watch out: this is a pointer in a data register!
  998.         Attr          -- (UBYTE *) If a pointer is provided, the UBYTE is filled
  999.                 with the record attributes. You may provide NULL.
  1000.                 Assembler users watch out: this is a pointer in a data register!
  1001.  
  1002.    RESULT
  1003.         Length        -- (LONG) Record bytes that were really read, or -1 if
  1004.                 an error occured.
  1005.  
  1006.    NOTE
  1007.         This function requires PalmOS 2.0 or higher. There is workaround
  1008.         for OS 1.0, but since it is quite outdated, I see no reason to
  1009.         implement it. If you require it, please get in contact with me.
  1010.  
  1011.         No, there is no longer function name in this library. ;-)
  1012.  
  1013.    BUGS
  1014.  
  1015.    SEE ALSO
  1016.  
  1017.  
  1018. palmlink.library/DLP_ReadRecordByID
  1019.  
  1020.    NAME
  1021.         DLP_ReadRecordByID - Read a record by ID
  1022.  
  1023.    SYNOPSIS
  1024.         Length = DLP_ReadRecordByID(Socket,DBHandle,ID,Buffer,Index,Size,Attr,Cat);
  1025.          D0.l                        A0.l    D0.l  D1.l A1.l  A2.l  A3.l D2.l D3.l
  1026.  
  1027.         LONG DLP_ReadRecordByID(APTR,LONG,ULONG,APTR,UWORD *,UWORD *,UBYTE *,UBYTE *);
  1028.  
  1029.    FUNCTION
  1030.         Read a record from the database, by its ID.
  1031.  
  1032.    INPUTS
  1033.         Socket        -- (APTR) Socket
  1034.         DBHandle      -- (LONG) Database handle
  1035.         ID            -- (ULONG) Record ID
  1036.         Buffer        -- (APTR) Buffer for the record. The buffer must have
  1037.                 a sufficient size of 65535 byte.
  1038.         Index         -- (UWORD *) If a pointer is provided, the record index
  1039.                 is copied there. You may provide NULL.
  1040.         Size          -- (UWORD *) If a pointer is provided, the UWORD is filled
  1041.                 with the size of this record. You may provide NULL.
  1042.         Attr          -- (UBYTE *) If a pointer is provided, the record attribute
  1043.                 is copied there. You may provide NULL.
  1044.                 Assembler users watch out: this is a pointer in a data register!
  1045.         Cat           -- (UBYTE *) If a pointer is provided, the record category
  1046.                 is copied there. You may provide NULL.
  1047.                 Assembler users watch out: this is a pointer in a data register!
  1048.  
  1049.  
  1050.    RESULT
  1051.         Length        -- (LONG) Record bytes that were really read, or -1 if
  1052.                 an error occured.
  1053.  
  1054.    NOTE
  1055.  
  1056.    BUGS
  1057.  
  1058.    SEE ALSO
  1059.  
  1060.  
  1061. palmlink.library/DLP_ReadRecordByIndex
  1062.  
  1063.    NAME
  1064.         DLP_ReadRecordByIndex - Read a record by Index
  1065.  
  1066.    SYNOPSIS
  1067.         Length = DLP_ReadRecordByIndex(Socket,DBHandle,Index,Buffer,ID,Size,Attr,Cat);
  1068.          D0.l                           A0.l    D0.l    D1.l A1.l  A2.l A3.l D2.l D3.l
  1069.  
  1070.         LONG DLP_ReadRecordByIndex(APTR,LONG,UWORD,APTR,ULONG *,UWORD *,UBYTE *,UBYTE *);
  1071.  
  1072.    FUNCTION
  1073.         Read a record from the database, by its index.
  1074.  
  1075.    INPUTS
  1076.         Socket        -- (APTR) Socket
  1077.         DBHandle      -- (LONG) Database handle
  1078.         Index         -- (UWORD) Index of the record
  1079.         Buffer        -- (APTR) Buffer for the record. The buffer must have
  1080.                 a sufficient size of 65535 byte.
  1081.         ID            -- (ULONG *) If a pointer is provided, the record ID
  1082.                 is copied there. You may provide NULL.
  1083.         Size          -- (UWORD *) If a pointer is provided, the UWORD is filled
  1084.                 with the size of this record. You may provide NULL.
  1085.         Attr          -- (UBYTE *) If a pointer is provided, the record attribute
  1086.                 is copied there. You may provide NULL.
  1087.                 Assembler users watch out: this is a pointer in a data register!
  1088.         Cat           -- (UBYTE *) If a pointer is provided, the record category
  1089.                 is copied there. You may provide NULL.
  1090.                 Assembler users watch out: this is a pointer in a data register!
  1091.  
  1092.  
  1093.    RESULT
  1094.         Length        -- (LONG) Record bytes that were really read, or -1 if
  1095.                 an error occured.
  1096.  
  1097.    NOTE
  1098.  
  1099.    BUGS
  1100.  
  1101.    SEE ALSO
  1102.  
  1103.  
  1104. palmlink.library/DLP_ReadResourceByIndex
  1105.  
  1106.    NAME
  1107.         DLP_ReadResourceByIndex - Read a resource by index
  1108.  
  1109.    SYNOPSIS
  1110.         Length = DLP_ReadResourceByIndex(Socket,DBHandle,Index,Buffer,Type,ID,Size)
  1111.           D0.l                            A0.l    D0.l    D1.w  A1.l  A2.l A3.l D2.l
  1112.  
  1113.         LONG DLP_ReadResourceByIndex(APTR,LONG,UWORD,APTR,ULONG *,UWORD *,UWORD *);
  1114.  
  1115.    FUNCTION
  1116.         Read a resource from the database, by its index.
  1117.  
  1118.    INPUTS
  1119.         Socket        -- (APTR) Socket
  1120.         DBHandle      -- (LONG) Database handle
  1121.         Index         -- (UWORD) Index of the resource
  1122.         Buffer        -- (APTR) Buffer for the resource. The buffer must have
  1123.                 a sufficient size of 65535 byte.
  1124.         Type          -- (ULONG *) If a pointer is provided, the resource type
  1125.                 is copied there. You may provide NULL.
  1126.         ID            -- (UWORD *) If a pointer is provided, the resource ID
  1127.                 is copied there. You may provide NULL.
  1128.         Size          -- (UWORD *) If a pointer is provided, the UWORD is filled
  1129.                 with the size of this resource. You may provide NULL.
  1130.                 Assembler users watch out: this is a pointer in a data register!
  1131.  
  1132.    RESULT
  1133.         Length        -- (LONG) Resource bytes that were really read, or -1 if
  1134.                 an error occured.
  1135.  
  1136.    NOTE
  1137.  
  1138.    BUGS
  1139.  
  1140.    SEE ALSO
  1141.  
  1142.  
  1143. palmlink.library/DLP_ReadResourceByType
  1144.  
  1145.    NAME
  1146.         DLP_ReadResourceByType - Read a resource by its type
  1147.  
  1148.    SYNOPSIS
  1149.         Length = DLP_ReadResourceByType(Socket,DBHandle,Type,ID,Buffer,Index,Size)
  1150.           D0.l                           A0.l   D0.l    D1.l D2.w A1.l  A2.l A3.l
  1151.  
  1152.         LONG DLP_ReadResourceByType(APTR,LONG,ULONG,UWORD,APTR,UWORD *,UWORD *);
  1153.  
  1154.    FUNCTION
  1155.         Read a resource from the database, by its type and ID.
  1156.  
  1157.    INPUTS
  1158.         Socket        -- (APTR) Socket
  1159.         DBHandle      -- (LONG) Database handle
  1160.         Type          -- (ULONG) Resource type
  1161.         ID            -- (UWORD) Resource ID
  1162.         Buffer        -- (APTR) Buffer for the resource. The buffer must have
  1163.                 a sufficient size of 65535 byte.
  1164.         Index         -- (UWORD *) If a pointer is provided, the UWORD is filled
  1165.                 with the index of this resource. You may provide NULL.
  1166.         Size          -- (UWORD *) If a pointer is provided, the UWORD is filled
  1167.                 with the size of this resource. You may provide NULL.
  1168.  
  1169.    RESULT
  1170.         Length        -- (LONG) Resource bytes that were really read, or -1 if
  1171.                 an error occured.
  1172.  
  1173.    NOTE
  1174.  
  1175.    BUGS
  1176.  
  1177.    SEE ALSO
  1178.  
  1179.  
  1180. palmlink.library/DLP_ReadSortBlock
  1181.  
  1182.    NAME
  1183.         DLP_ReadSortBlock - Read a sort block
  1184.  
  1185.    SYNOPSIS
  1186.         Length = DLP_ReadSortBlock(Socket,DBHandle,Offset,Buffer,Length)
  1187.           D0.l                      A0.l    D0.l    D1.w   A1.l   D2.w
  1188.  
  1189.         LONG DLP_ReadSortBlock(APTR,LONG,UWORD,APTR,UWORD);
  1190.  
  1191.    FUNCTION
  1192.         Read the sort block of the database.
  1193.  
  1194.    INPUTS
  1195.         Socket        -- (APTR) Socket
  1196.         DBHandle      -- (LONG) Database handle
  1197.         Offset        -- (UWORD) Offset into the sort block
  1198.         Buffer        -- (APTR) Buffer for the sort block
  1199.         Length        -- (UWORD) Length of the buffer. As you see, the maximum
  1200.                 size is 65535 byte.
  1201.  
  1202.    RESULT
  1203.         Length        -- (LONG) SortBlock bytes that were really read, or -1 if
  1204.                 an error occured.
  1205.  
  1206.    NOTE
  1207.  
  1208.    BUGS
  1209.  
  1210.    SEE ALSO
  1211.  
  1212.  
  1213. palmlink.library/DLP_ResetDBIndex
  1214.  
  1215.    NAME
  1216.         DLP_ResetDBIndex - Restart from the first DB entry
  1217.  
  1218.    SYNOPSIS
  1219.         Success = DLP_ResetDBIndex(Socket,DBHandle)
  1220.           D0.l                      A0.l    D0.l
  1221.  
  1222.         int DLP_ResetDBIndex(APTR,LONG);
  1223.  
  1224.    FUNCTION
  1225.         Resets the internal DB index counter to the start of the
  1226.         database.
  1227.  
  1228.    INPUTS
  1229.         Socket        -- (APTR) Socket
  1230.         DBHandle      -- (LONG) Database handle
  1231.  
  1232.    RESULT
  1233.         Success       -- (int) FALSE: an error occured, see PL_LastError()
  1234.  
  1235.    NOTE
  1236.  
  1237.    BUGS
  1238.  
  1239.    SEE ALSO
  1240.  
  1241.  
  1242. palmlink.library/DLP_ResetLastSyncPC
  1243.  
  1244.    NAME
  1245.         DLP_ResetLastSyncPC - Clears the LastSyncPC
  1246.  
  1247.    SYNOPSIS
  1248.         Success = DLP_ResetLastSyncPC(Socket)
  1249.           D0.l                         A0.l
  1250.  
  1251.         int DLP_ResetLastSyncPC(APTR);
  1252.  
  1253.    FUNCTION
  1254.         Reset the LastSyncPC field in the UserInfo.
  1255.  
  1256.    INPUTS
  1257.         Socket        -- (APTR) Socket
  1258.  
  1259.    RESULT
  1260.         Success       -- (int) FALSE: an error occured, see PL_LastError()
  1261.  
  1262.    NOTE
  1263.  
  1264.    BUGS
  1265.  
  1266.    SEE ALSO
  1267.  
  1268.  
  1269. palmlink.library/DLP_ResetSyncFlags
  1270.  
  1271.    NAME
  1272.         DLP_ResetSyncFlags - Reset all sync flags of the database
  1273.  
  1274.    SYNOPSIS
  1275.         Success = DLP_ResetSyncFlags(Socket,DBHandle)
  1276.           D0.l                        A0.l    D0.l
  1277.  
  1278.         int DLP_ResetSyncFlags(APTR,LONG);
  1279.  
  1280.    FUNCTION
  1281.         All sync flags of the database are reset.
  1282.  
  1283.    INPUTS
  1284.         Socket        -- (APTR) Socket
  1285.         DBHandle      -- (LONG) Handle of the database.
  1286.  
  1287.    RESULT
  1288.         Success       -- (int) TRUE: this call succeeded. FALSE: an
  1289.                 error occured (see PL_LastError()).
  1290.  
  1291.    NOTE
  1292.  
  1293.    BUGS
  1294.  
  1295.    SEE ALSO
  1296.  
  1297.  
  1298. palmlink.library/DLP_ResetSystem
  1299.  
  1300.    NAME
  1301.         DLP_ResetSystem - Reset the Palm Pilot
  1302.  
  1303.    SYNOPSIS
  1304.         Success = DLP_ResetSystem(Socket)
  1305.           D0.l                     A0.l
  1306.  
  1307.         int DLP_ResetSystem(APTR);
  1308.  
  1309.    FUNCTION
  1310.         Reset the Palm Pilot when the connection is closed.
  1311.  
  1312.    INPUTS
  1313.         Socket        -- (APTR) Socket
  1314.  
  1315.    RESULT
  1316.         Success       -- (int) FALSE: an error occured, see PL_LastError()
  1317.  
  1318.    NOTE
  1319.  
  1320.    BUGS
  1321.  
  1322.    SEE ALSO
  1323.  
  1324.  
  1325. palmlink.library/DLP_SetNetSyncInfo
  1326.  
  1327.    NAME
  1328.         DLP_SetNetSyncInfo - Set information about net sync
  1329.  
  1330.    SYNOPSIS
  1331.         Success = DLP_SetNetSyncInfo(Socket,NetSync)
  1332.           D0.l                        A0.l   A1.l
  1333.  
  1334.         int DLP_SetNetSyncInfo(APTR,struct DLP_NetSyncInfo *);
  1335.  
  1336.    FUNCTION
  1337.         Set information about net sync from the DLP_NetSyncInfo structure.
  1338.  
  1339.    INPUTS
  1340.         Socket        -- (APTR) Socket
  1341.         NetSync       -- (struct DLP_NetSyncInfo *) NetSync to be set
  1342.  
  1343.    RESULT
  1344.         Success       -- (int) TRUE: NetSyncInfo has been set.
  1345.  
  1346.    NOTE
  1347.         This function requires PalmOS 2.0 or higher. There is workaround
  1348.         for OS 1.0, but since it is quite outdated, I see no reason to
  1349.         implement it. If you require it, please get in contact with me.
  1350.  
  1351.    BUGS
  1352.  
  1353.    SEE ALSO
  1354.         DLP_GetNetSyncInfo()
  1355.  
  1356.  
  1357. palmlink.library/DLP_SetSysTime
  1358.  
  1359.    NAME
  1360.         DLP_SetSysTime - Set the Pilot system time
  1361.  
  1362.    SYNOPSIS
  1363.         Success = DLP_SetSysTime(Socket,Time)
  1364.           D0.l                    A0.l  A1.l
  1365.  
  1366.         int DLP_SetSysTime(APTR,struct DLP_SysTime *);
  1367.  
  1368.    FUNCTION
  1369.         The internal clock of the Palm Pilot is set according to the
  1370.         passed DLP_SysTime structure.
  1371.  
  1372.    INPUTS
  1373.         Socket        -- (APTR) Socket
  1374.         Time          -- (struct DLP_SysTime *) Time to set
  1375.  
  1376.    RESULT
  1377.         Success       -- (int) TRUE: Time has been set.
  1378.  
  1379.    NOTE
  1380.  
  1381.    BUGS
  1382.  
  1383.    SEE ALSO
  1384.         DLP_GetSysTime()
  1385.  
  1386.  
  1387. palmlink.library/DLP_SetUserInfo
  1388.  
  1389.    NAME
  1390.         DLP_SetUserInfo - Set information about the Pilot user
  1391.  
  1392.    SYNOPSIS
  1393.         Success = DLP_SetUserInfo(Socket,User)
  1394.           D0.l                     A0.l  A1.l
  1395.  
  1396.         int DLP_SetUserInfo(APTR,struct DLP_UserInfo *);
  1397.  
  1398.    FUNCTION
  1399.         Set information about the Pilot user (most probably you ;-)
  1400.         from the DLP_UserInfo structure.
  1401.  
  1402.    INPUTS
  1403.         Socket        -- (APTR) Socket
  1404.         User          -- (struct DLP_UserInfo *) UserInfo to be set
  1405.  
  1406.    RESULT
  1407.         Success       -- (int) TRUE: UserInfo has been set.
  1408.  
  1409.    NOTE
  1410.  
  1411.    BUGS
  1412.  
  1413.    SEE ALSO
  1414.         DLP_GetUserInfo()
  1415.  
  1416.  
  1417. palmlink.library/DLP_WriteAppBlock
  1418.  
  1419.    NAME
  1420.         DLP_WriteAppBlock - Write an application block
  1421.  
  1422.    SYNOPSIS
  1423.         Success = DLP_WriteAppBlock(Socket,DBHandle,Buffer,Length)
  1424.           D0.l                      A0.l    D0.l    A1.l   D1.w
  1425.  
  1426.         int DLP_WriteAppBlock(APTR,LONG,APTR,UWORD);
  1427.  
  1428.    FUNCTION
  1429.         Write the application block into the database.
  1430.  
  1431.    INPUTS
  1432.         Socket        -- (APTR) Socket
  1433.         DBHandle      -- (LONG) Database handle
  1434.         Buffer        -- (APTR) Buffer for the application block
  1435.         Length        -- (UWORD) Length of the buffer. As you see, the maximum
  1436.                 size is 65535 byte.
  1437.  
  1438.    RESULT
  1439.         Success       -- (int) TRUE: AppBlock has been written successfully
  1440.  
  1441.    NOTE
  1442.  
  1443.    BUGS
  1444.  
  1445.    SEE ALSO
  1446.  
  1447.  
  1448. palmlink.library/DLP_WriteAppPreference
  1449.  
  1450.    NAME
  1451.         DLP_WriteAppPreference - Write the preference of an application
  1452.  
  1453.    SYNOPSIS
  1454.         Success = DLP_WriteAppPreference(Socket,Creator,ID,Saved,Version,Buffer,Length)
  1455.           D0.l                            A0.l   D0.l  D1.w D2.w  D3.w    A1.l   D4.w
  1456.  
  1457.         int DLP_WriteAppPreference(APTR,ULONG,UWORD,BOOL,UWORD,APTR,UWORD);
  1458.  
  1459.    FUNCTION
  1460.         Write the preferences of an application. You can choose between the
  1461.         saved and the temporary version of the preference.
  1462.  
  1463.    INPUTS
  1464.         Socket        -- (APTR) Socket
  1465.         Creator       -- (ULONG) Creator of the application
  1466.         ID            -- (UWORD) ID number of the preference (lets an
  1467.                 application have multiple preferences)
  1468.         Saved         -- (BOOL) TRUE: save the preference, FALSE: use
  1469.                 the preference as current settings.
  1470.         Version       -- (UWORD) Preference version
  1471.         Buffer        -- (APTR) Buffer where the preferences are stored
  1472.         Length        -- (UWORD) Length of the preference block
  1473.  
  1474.    RESULT
  1475.         Success       -- (int) TRUE: Preference has been set successfully.
  1476.  
  1477.    NOTE
  1478.         This function requires PalmOS 2.0 or higher. There is workaround
  1479.         for OS 1.0, but since it is quite outdated, I see no reason to
  1480.         implement it. If you require it, please get in contact with me.
  1481.  
  1482.    BUGS
  1483.  
  1484.    SEE ALSO
  1485.  
  1486.  
  1487. palmlink.library/DLP_WriteRecord
  1488.  
  1489.    NAME
  1490.         DLP_WriteRecord - Write a record to the database
  1491.  
  1492.    SYNOPSIS
  1493.         Success = DLP_WriteRecord(Socket,DBHandle,Flags,ID,CatID,Buffer,Length,NewID)
  1494.           D0.l                     A0.l   D0.l    D1.b D2.l D3.b  A1.l   D4.w   A2.l
  1495.  
  1496.         int DLP_WriteRecord(APTR,LONG,UBYTE,ULONG,UBYTE,APTR,UWORD,ULONG *);
  1497.  
  1498.    FUNCTION
  1499.         Write a record to the database.
  1500.  
  1501.    INPUTS
  1502.         Socket        -- (APTR) Socket
  1503.         DBHandle      -- (LONG) Database handle
  1504.         Flags         -- (UBYTE) Write flags (see includes)
  1505.         ID            -- (ULONG) Record ID
  1506.         CatID         -- (UBYTE) Record Category ID
  1507.         Buffer        -- (APTR) Data to write to the record
  1508.         Length        -- (UWORD) Length of the buffer (as you see, a record
  1509.                 can only contain 65535 byte).
  1510.         NewID         -- (ULONG *) The record ID that has been used can be
  1511.                 returned in this buffer. Provide NULL if you don't need it.
  1512.  
  1513.    RESULT
  1514.         Success       -- (int) TRUE: Record has bee written.
  1515.  
  1516.    NOTE
  1517.  
  1518.    BUGS
  1519.  
  1520.    SEE ALSO
  1521.  
  1522.  
  1523. palmlink.library/DLP_WriteResource
  1524.  
  1525.    NAME
  1526.         DLP_WriteResource - Write a resource to the database
  1527.  
  1528.    SYNOPSIS
  1529.         Success = DLP_WriteResource(Socket,DBHandle,Type,ID,Buffer,Length)
  1530.           D0.l                       A0.l   D0.l    D1.l D2.w A1.l  D3.w
  1531.  
  1532.         int DLP_WriteResource(APTR,LONG,ULONG,UWORD,APTR,UWORD);
  1533.  
  1534.    FUNCTION
  1535.         Write a resource to the database.
  1536.  
  1537.    INPUTS
  1538.         Socket        -- (APTR) Socket
  1539.         DBHandle      -- (LONG) Database handle
  1540.         Type          -- (ULONG) Resource type
  1541.         ID            -- (UWORD) Resource ID
  1542.         Buffer        -- (APTR) Data to write to the resource
  1543.         Length        -- (UWORD) Length of the buffer (as you see, a resource
  1544.                 can only contain 65535 byte).
  1545.  
  1546.    RESULT
  1547.         Success       -- (int) TRUE: Resource has been written.
  1548.  
  1549.    NOTE
  1550.  
  1551.    BUGS
  1552.  
  1553.    SEE ALSO
  1554.  
  1555.  
  1556. palmlink.library/DLP_WriteSortBlock
  1557.  
  1558.    NAME
  1559.         DLP_WriteSortBlock - Write a sort block
  1560.  
  1561.    SYNOPSIS
  1562.         Success = DLP_WriteSortBlock(Socket,DBHandle,Buffer,Length)
  1563.           D0.l                       A0.l    D0.l    A1.l   D1.w
  1564.  
  1565.         int DLP_WriteSortBlock(APTR,LONG,APTR,UWORD);
  1566.  
  1567.    FUNCTION
  1568.         Write the sort block into the database.
  1569.  
  1570.    INPUTS
  1571.         Socket        -- (APTR) Socket
  1572.         DBHandle      -- (LONG) Database handle
  1573.         Buffer        -- (APTR) Buffer for the sort block
  1574.         Length        -- (UWORD) Length of the buffer. As you see, the maximum
  1575.                 size is 65535 byte.
  1576.  
  1577.    RESULT
  1578.         Success       -- (int) TRUE: SortBlock has been written successfully
  1579.  
  1580.    NOTE
  1581.  
  1582.    BUGS
  1583.  
  1584.    SEE ALSO
  1585.  
  1586.  
  1587. palmlink.library/PL_Accept
  1588.  
  1589.    NAME
  1590.         PL_Accept - accept a connection
  1591.  
  1592.    SYNOPSIS
  1593.         Success = PL_Accept(Socket, Timeout)
  1594.         D0.l                 A0.l    D0.l
  1595.  
  1596.         int PL_Accept(APTR, ULONG);
  1597.  
  1598.    FUNCTION
  1599.         Wait for a connection request from Palm Pilot, and accept it. If
  1600.         there was no connection until Timeout, a timeout error will be
  1601.         returned.
  1602.  
  1603.         Usually, the connection is started by pressing the HotSync button
  1604.         on the cradle.
  1605.  
  1606.         You can read the error code using PL_LastError().
  1607.  
  1608.    INPUTS
  1609.         Socket        -- (APTR) Socket
  1610.         Timeout       -- (ULONG) Timeout (seconds) until this function
  1611.                          returns.
  1612.  
  1613.    RESULT
  1614.         Success       -- (int) TRUE if a connection request has been
  1615.                          accepted.
  1616.  
  1617.    NOTE
  1618.  
  1619.    BUGS
  1620.         The timeout may be some seconds longer than provided.
  1621.  
  1622.    SEE ALSO
  1623.  
  1624. palmlink.library/PL_AddRexxHandle
  1625.  
  1626.    NAME
  1627.         PL_AddRexxHandle - Add an ARexx created handle
  1628.  
  1629.    SYNOPSIS
  1630.         PL_AddRexxHandle(Socket, Name)
  1631.                          A0.l    A1.l
  1632.  
  1633.         void PL_AddRexxHandle(APTR, STRPTR);
  1634.  
  1635.    FUNCTION
  1636.         After a socket has been created by an ARexx function, its handle
  1637.         is maintained by the palmlink.library.
  1638.  
  1639.         This function adds the new handle to the internal list.
  1640.  
  1641.    INPUTS
  1642.         Socket        -- (APTR) Socket
  1643.         Name          -- (STRPTR) Name of the handle
  1644.  
  1645.    RESULT
  1646.  
  1647.    NOTE
  1648.         This is a PRIVATE function. Do NOT use it. You have been warned! ;-)
  1649.  
  1650.    BUGS
  1651.         If the name does already exist, it will exist twice after this call.
  1652.  
  1653.    SEE ALSO
  1654.         PL_DeleteRexxHandle(), PL_FindRexxHandle()
  1655.  
  1656. palmlink.library/PL_CloseSocket
  1657.  
  1658.    NAME
  1659.         PL_CloseSocket - close a socket to a Palm Pilot
  1660.  
  1661.    SYNOPSIS
  1662.         PL_CloseSocket(Socket)
  1663.                         A0.l
  1664.  
  1665.         void PL_CloseSocket(APTR);
  1666.  
  1667.    FUNCTION
  1668.         Close a socket to a Palm Pilot. Make sure to close all data bases
  1669.         before. PalmLink won't do this for you.
  1670.  
  1671.    INPUTS
  1672.         Socket        -- (APTR) Socket to be closed. NULL will do nothing.
  1673.  
  1674.    RESULT
  1675.  
  1676.    NOTE
  1677.  
  1678.    BUGS
  1679.  
  1680.    SEE ALSO
  1681.         PL_OpenSocket()
  1682.  
  1683.  
  1684. palmlink.library/PL_CMPAbort
  1685.  
  1686.    NAME
  1687.         PL_CMPAbort - Abort a connection
  1688.  
  1689.    SYNOPSIS
  1690.         Success = PL_CMPAbort(Socket,Reason)
  1691.         D0.l                   A0.l   D0.b
  1692.  
  1693.         int PL_CMPAbort(APTR,UBYTE);
  1694.  
  1695.    FUNCTION
  1696.         Abort a connection, using CMP (Connection Management Protocol).
  1697.         The appropriate reason is transmitted.
  1698.  
  1699.         If this function fails (i.e. it returns false), you can read
  1700.         the error code using PL_LastError().
  1701.  
  1702.         This is a low level call, and is used by the palmlink.library
  1703.         itself. Usually, you do not need to use this function.
  1704.  
  1705.    INPUTS
  1706.         Socket        -- (APTR) Socket
  1707.         Reason        -- (UBYTE) Reason for the abortion
  1708.  
  1709.    RESULT
  1710.         Success       -- (int) TRUE: The abort request has been sent
  1711.                 successfully. FALSE: An error occured.
  1712.  
  1713.    NOTE
  1714.  
  1715.    BUGS
  1716.  
  1717.    SEE ALSO
  1718.         PL_CMPRead(), PL_CMPInit(), PL_CMPWakeUp()
  1719.  
  1720.  
  1721. palmlink.library/PL_CMPInit
  1722.  
  1723.    NAME
  1724.         PL_CMPInit - Initialize a connection
  1725.  
  1726.    SYNOPSIS
  1727.         Success = PL_CMPInit(Socket,Rate)
  1728.         D0.l                  A0.l  D0.l
  1729.  
  1730.         int PL_CMPInit(APTR,ULONG);
  1731.  
  1732.    FUNCTION
  1733.         After being waked up, the connection is initialized using
  1734.         CMP (Connection Management Protocol). The desired baud rate
  1735.         is passed. It must be below the maximum baud rate that has
  1736.         been transmitted by the WakeUp packet. If the Palm Pilot does
  1737.         not support the desired rate, this function will fail.
  1738.  
  1739.         If this function fails (i.e. it returns false), you can read
  1740.         the error code using PL_LastError().
  1741.  
  1742.         This is a low level call, and is used by the palmlink.library
  1743.         itself. Usually, you do not need to use this function.
  1744.  
  1745.    INPUTS
  1746.         Socket        -- (APTR) Socket
  1747.         Rate          -- (ULONG) Desired baud rate, in bps
  1748.  
  1749.    RESULT
  1750.         Success       -- (int) TRUE: The initialization has been sent
  1751.                 successfully. FALSE: An error occured.
  1752.  
  1753.    NOTE
  1754.         It is guaranteed that the Palm Pilot supports 9600 bps. The
  1755.         maximum baud rate (at least of the Palm III) is 57600 bps.
  1756.  
  1757.         This call will not set the serial interface to the new baud
  1758.         rate!
  1759.  
  1760.    BUGS
  1761.  
  1762.    SEE ALSO
  1763.         PL_CMPRead(), PL_CMPAbort(), PL_CMPWakeUp()
  1764.  
  1765.  
  1766. palmlink.library/PL_CMPRead
  1767.  
  1768.    NAME
  1769.         PL_CMPRead - read a packet using CMP
  1770.  
  1771.    SYNOPSIS
  1772.         Success = PL_CMPRead(Socket,CMP)
  1773.         D0.l                  A0.l  A1.l
  1774.  
  1775.         int PL_CMPRead(APTR,struct PL_CMP *);
  1776.  
  1777.    FUNCTION
  1778.         Read a CMP packet from the Palm Pilot. A space for the CMP
  1779.         structure must be provided.
  1780.  
  1781.         If this function fails (i.e. it returns false), you can read
  1782.         the error code using PL_LastError().
  1783.  
  1784.         This is a low level call, and is used by the palmlink.library
  1785.         itself. Usually, you do not need to use this function.
  1786.  
  1787.    INPUTS
  1788.         Socket        -- (APTR) Socket
  1789.         CMP           -- (struct PL_CMP *) CMP structure to be filled
  1790.  
  1791.    RESULT
  1792.         Success       -- (int) TRUE: The CMP structure has been read
  1793.                 successfully. FALSE: An error occured.
  1794.  
  1795.    NOTE
  1796.  
  1797.    BUGS
  1798.  
  1799.    SEE ALSO
  1800.         PL_CMPInit(), PL_CMPAbort(), PL_CMPWakeUp()
  1801.  
  1802.  
  1803. palmlink.library/PL_CMPWakeUp
  1804.  
  1805.    NAME
  1806.         PL_CMPWakeUp - Wake up the remote side
  1807.  
  1808.    SYNOPSIS
  1809.         Success = PL_CMPWakeUp(Socket,MaxRate)
  1810.         D0.l                    A0.l   D0.l
  1811.  
  1812.         int PL_CMPWakeUp(APTR,ULONG);
  1813.  
  1814.    FUNCTION
  1815.         Wake up the remote side of a connection, using CMP (Connection
  1816.         Management Protocol). We pass the maximum baud rate we support.
  1817.         The Palm Pilot will answer with a CMP Init packet, giving the
  1818.         baud rate it will use for further communication.
  1819.  
  1820.         If this function fails (i.e. it returns false), you can read
  1821.         the error code using PL_LastError().
  1822.  
  1823.         This is a low level call, and is used by the palmlink.library
  1824.         itself. Usually, you do not need to use this function.
  1825.  
  1826.    INPUTS
  1827.         Socket        -- (APTR) Socket
  1828.         MaxRate       -- (ULONG) Maximum baud rate, in bps
  1829.  
  1830.    RESULT
  1831.         Success       -- (int) TRUE: The wake up has been sent
  1832.                 successfully. FALSE: An error occured.
  1833.  
  1834.    NOTE
  1835.         This call will not set the serial interface to the new baud
  1836.         rate!
  1837.  
  1838.    BUGS
  1839.  
  1840.    SEE ALSO
  1841.         PL_CMPRead(), PL_CMPAbort(), PL_CMPInit()
  1842.  
  1843.  
  1844. palmlink.library/PL_Connect
  1845.  
  1846.    NAME
  1847.         PL_Connect - initiate a connection to the Palm Pilot
  1848.  
  1849.    SYNOPSIS
  1850.         Success = PL_Connect(Socket)
  1851.         D0.l                  A0.l
  1852.  
  1853.         int PL_Connect(APTR);
  1854.  
  1855.    FUNCTION
  1856.         Initiate a connection to the Palm Pilot. If the connection could
  1857.         not be established, or was refused, an error occures.
  1858.  
  1859.         You can read the error code using PL_LastError().
  1860.  
  1861.    INPUTS
  1862.         Socket        -- (APTR) Socket
  1863.  
  1864.    RESULT
  1865.         Success       -- (int) TRUE if a connection has been established.
  1866.  
  1867.    NOTE
  1868.  
  1869.    BUGS
  1870.         This function does not seem to work since the Palm Pilot does not
  1871.         accept wakeup requests. I will have a look at this later. Anyhow
  1872.         you should use PL_Accept() and let the user decide when he wants
  1873.         to sync.
  1874.  
  1875.    SEE ALSO
  1876.  
  1877. palmlink.library/PL_DeleteRexxHandle
  1878.  
  1879.    NAME
  1880.         PL_DeleteRexxHandle - Deletes an ARexx created handle
  1881.  
  1882.    SYNOPSIS
  1883.         PL_DeleteRexxHandle(Name)
  1884.                             A0.l
  1885.  
  1886.         void PL_DeleteRexxHandle(STRPTR);
  1887.  
  1888.    FUNCTION
  1889.         After a socket has been created by an ARexx function, its handle
  1890.         is maintained by the palmlink.library.
  1891.  
  1892.         This function deletes an existing handle from the internal list.
  1893.  
  1894.         If the handle did not exist, nothing will happen.
  1895.  
  1896.    INPUTS
  1897.         Name          -- (STRPTR) Name of the handle
  1898.  
  1899.    RESULT
  1900.  
  1901.    NOTE
  1902.         This is a PRIVATE function. Do NOT use it. You have been warned! ;-)
  1903.  
  1904.    BUGS
  1905.  
  1906.    SEE ALSO
  1907.         PL_AddRexxHandle(), PL_FindRexxHandle()
  1908.  
  1909. palmlink.library/PL_DLPInit
  1910.  
  1911.    NAME
  1912.         PL_DLPInit - Initialize a DLP data transfer
  1913.  
  1914.    SYNOPSIS
  1915.         PL_DLPInit(Socket)
  1916.                     A0.l
  1917.  
  1918.         void PL_DLPInit(APTR);
  1919.  
  1920.    FUNCTION
  1921.         The internal DLP buffer is initialized and prepared for a
  1922.         new DLP transmission.
  1923.  
  1924.         This is a low level call, and is used by the palmlink.library
  1925.         itself. Usually, you do not need to use this function.
  1926.  
  1927.    INPUTS
  1928.         Socket        -- (APTR) Socket
  1929.  
  1930.    RESULT
  1931.  
  1932.    NOTE
  1933.         The DLP buffer has sufficient space for a whole DLP packet
  1934.         of 64KByte.
  1935.  
  1936.    BUGS
  1937.         There is no arbitration yet. Only the task that initiated the
  1938.         socket is allowed to use this function.
  1939.  
  1940.         Nested calls are not supported.
  1941.  
  1942.         You must not patch this function.
  1943.  
  1944.    SEE ALSO
  1945.         PL_DLPWriteByte(), PL_DLPWriteWord(), PL_DLPWriteLong(),
  1946.         PL_DLPWrite(), PL_DLPTstWrite(), PL_DLPSend(), PL_DLPRead()
  1947.  
  1948.  
  1949. palmlink.library/PL_DLPRead
  1950.  
  1951.    NAME
  1952.         PL_DLPRead - Read the DLP reply
  1953.  
  1954.    SYNOPSIS
  1955.         Length = PL_DLPRead(Socket,Buffer,Length)
  1956.          D0.l                A0.l   A1.l   D0.l
  1957.  
  1958.         LONG PL_DLPRead(APTR,APTR,LONG);
  1959.  
  1960.    FUNCTION
  1961.         After a command has been sent using, PL_DLPSend(), you can use
  1962.         this call to sequential read the reply. The current part is
  1963.         copied into the buffer.
  1964.  
  1965.         This is a low level call, and is used by the palmlink.library
  1966.         itself. Usually, you do not need to use this function.
  1967.  
  1968.    INPUTS
  1969.         Socket        -- (APTR) Socket
  1970.         Buffer        -- (APTR) Buffer that will contain the part of
  1971.                 the reply packet.
  1972.         Length        -- (LONG) Length of the buffer
  1973.  
  1974.    RESULT
  1975.         Length        -- (LONG) Bytes that were really read.
  1976.  
  1977.    NOTE
  1978.  
  1979.    BUGS
  1980.         Currently, the returned length always matches the buffer length,
  1981.         regardless of the number of bytes that were really available.
  1982.  
  1983.         You must not patch this function.
  1984.  
  1985.    SEE ALSO
  1986.         PL_DLPInit(), PL_DLPWriteByte(), PL_DLPWriteWord(),
  1987.         PL_DLPWriteLong(), PL_DLPWrite(), PL_DLPTstWrite(), PL_DLPSend()
  1988.  
  1989.  
  1990. palmlink.library/PL_DLPSend
  1991.  
  1992.    NAME
  1993.         PL_DLPSend - Send a command and the DLP buffer
  1994.  
  1995.    SYNOPSIS
  1996.         Length = PL_DLPSend(Socket,Cmd,Arg)
  1997.          D0.l                A0.l  D0.b D1.b
  1998.  
  1999.         LONG PL_DLPSend(APTR,UBYTE,UBYTE);
  2000.  
  2001.    FUNCTION
  2002.         The current DLP buffer is sent to the Pilot, and the provided
  2003.         command is executed. The reply packet is stored into the DLP
  2004.         buffer; its size is returned.
  2005.  
  2006.         This is a low level call, and is used by the palmlink.library
  2007.         itself. Usually, you do not need to use this function.
  2008.  
  2009.    INPUTS
  2010.         Socket        -- (APTR) Socket
  2011.         Cmd           -- (UBYTE) Command code to be executed
  2012.         Arg           -- (UBYTE) Argument to the command
  2013.  
  2014.    RESULT
  2015.         Length        -- (LONG) Length of the received reply. 0 if
  2016.                 the call succeeded but no reply was sent. -1 if the
  2017.                 call failed (see PL_LastError()).
  2018.  
  2019.    NOTE
  2020.  
  2021.    BUGS
  2022.         You must not patch this function.
  2023.  
  2024.    SEE ALSO
  2025.         PL_DLPInit(), PL_DLPWriteByte(), PL_DLPWriteWord(),
  2026.         PL_DLPWriteLong(), PL_DLPWrite(), PL_DLPTstWrite(), PL_DLPRead()
  2027.  
  2028.  
  2029. palmlink.library/PL_DLPTstWrite
  2030.  
  2031.    NAME
  2032.         PL_DLPTstWrite - Test if there is sufficient space in the DLP buffer
  2033.  
  2034.    SYNOPSIS
  2035.         Success = PL_DLPTstWrite(Socket,Length)
  2036.           D0.l                    A0.l   D0.l
  2037.  
  2038.         int PL_DLPTstWrite(APTR,LONG);
  2039.  
  2040.    FUNCTION
  2041.         It is tested if a structure with the passed size will fit into
  2042.         the current DLP buffer.
  2043.  
  2044.         This is a low level call, and is used by the palmlink.library
  2045.         itself. Usually, you do not need to use this function.
  2046.  
  2047.    INPUTS
  2048.         Socket        -- (APTR) Socket
  2049.         Length        -- (LONG) Length of the structure
  2050.  
  2051.    RESULT
  2052.         Success       -- (int) TRUE: There is enough space left
  2053.  
  2054.    NOTE
  2055.  
  2056.    BUGS
  2057.         You must not patch this function.
  2058.  
  2059.    SEE ALSO
  2060.         PL_DLPInit(), PL_DLPWriteByte(), PL_DLPWriteWord(),
  2061.         PL_DLPWriteLong(), PL_DLPWrite(), PL_DLPSend(), PL_DLPRead()
  2062.  
  2063.  
  2064. palmlink.library/PL_DLPWrite
  2065.  
  2066.    NAME
  2067.         PL_DLPWrite - Write a structure to the DLP buffer
  2068.  
  2069.    SYNOPSIS
  2070.         Length = PL_DLPWrite(Socket,Structure,Length)
  2071.          D0.l                 A0.l    A1.l     D0.l
  2072.  
  2073.         LONG PL_DLPWrite(APTR,APTR,LONG);
  2074.  
  2075.    FUNCTION
  2076.         The provided structure is added to the DLP buffer.
  2077.  
  2078.         This is a low level call, and is used by the palmlink.library
  2079.         itself. Usually, you do not need to use this function.
  2080.  
  2081.    INPUTS
  2082.         Socket        -- (APTR) Socket
  2083.         Structure     -- (APTR) Data structure to be added
  2084.         Length        -- (LONG) Length of the structure
  2085.  
  2086.    RESULT
  2087.         Length        -- (LONG) Current length of the DLP packet
  2088.  
  2089.    NOTE
  2090.  
  2091.    BUGS
  2092.         PalmLink does not check if the structure really fit into
  2093.         the remaining DLP buffer space. If you are in doubt, use
  2094.         PL_DLPTstWrite() before.
  2095.  
  2096.         You must not patch this function.
  2097.  
  2098.    SEE ALSO
  2099.         PL_DLPInit(), PL_DLPWriteByte(), PL_DLPWriteWord(),
  2100.         PL_DLPWriteLong(), PL_DLPTstWrite(), PL_DLPSend(), PL_DLPRead()
  2101.  
  2102.  
  2103. palmlink.library/PL_DLPWriteByte
  2104.  
  2105.    NAME
  2106.         PL_DLPWriteByte - Write a byte to the DLP buffer
  2107.  
  2108.    SYNOPSIS
  2109.         Length = PL_DLPWriteByte(Socket,Data)
  2110.          D0.l                     A0.l  D0.b
  2111.  
  2112.         LONG PL_DLPWriteByte(APTR,BYTE);
  2113.  
  2114.    FUNCTION
  2115.         The provided byte is added to the DLP buffer.
  2116.  
  2117.         This is a low level call, and is used by the palmlink.library
  2118.         itself. Usually, you do not need to use this function.
  2119.  
  2120.    INPUTS
  2121.         Socket        -- (APTR) Socket
  2122.         Data          -- (BYTE) Data to be added
  2123.  
  2124.    RESULT
  2125.         Length        -- (LONG) Current length of the DLP packet
  2126.  
  2127.    NOTE
  2128.  
  2129.    BUGS
  2130.         You must not patch this function.
  2131.  
  2132.    SEE ALSO
  2133.         PL_DLPInit(), PL_DLPWriteWord(), PL_DLPWriteLong(),
  2134.         PL_DLPWrite(), PL_DLPTstWrite(), PL_DLPSend(), PL_DLPRead()
  2135.  
  2136.  
  2137. palmlink.library/PL_DLPWriteLong
  2138.  
  2139.    NAME
  2140.         PL_DLPWriteLong - Write a longword to the DLP buffer
  2141.  
  2142.    SYNOPSIS
  2143.         Length = PL_DLPWriteLong(Socket,Data)
  2144.          D0.l                     A0.l  D0.l
  2145.  
  2146.         LONG PL_DLPWriteLong(APTR,LONG);
  2147.  
  2148.    FUNCTION
  2149.         The provided longword is added to the DLP buffer.
  2150.  
  2151.         This is a low level call, and is used by the palmlink.library
  2152.         itself. Usually, you do not need to use this function.
  2153.  
  2154.    INPUTS
  2155.         Socket        -- (APTR) Socket
  2156.         Data          -- (BYTE) Data to be added
  2157.  
  2158.    RESULT
  2159.         Length        -- (LONG) Current length of the DLP packet
  2160.  
  2161.    NOTE
  2162.  
  2163.    BUGS
  2164.         You must not patch this function.
  2165.  
  2166.    SEE ALSO
  2167.         PL_DLPInit(), PL_DLPWriteByte(), PL_DLPWriteWord(),
  2168.         PL_DLPWrite(), PL_DLPTstWrite(), PL_DLPSend(), PL_DLPRead()
  2169.  
  2170.  
  2171. palmlink.library/PL_DLPWriteWord
  2172.  
  2173.    NAME
  2174.         PL_DLPWriteWord - Write a word to the DLP buffer
  2175.  
  2176.    SYNOPSIS
  2177.         Length = PL_DLPWriteWord(Socket,Data)
  2178.          D0.l                     A0.l  D0.w
  2179.  
  2180.         LONG PL_DLPWriteWord(APTR,WORD);
  2181.  
  2182.    FUNCTION
  2183.         The provided word is added to the DLP buffer.
  2184.  
  2185.         This is a low level call, and is used by the palmlink.library
  2186.         itself. Usually, you do not need to use this function.
  2187.  
  2188.    INPUTS
  2189.         Socket        -- (APTR) Socket
  2190.         Data          -- (BYTE) Data to be added
  2191.  
  2192.    RESULT
  2193.         Length        -- (LONG) Current length of the DLP packet
  2194.  
  2195.    NOTE
  2196.  
  2197.    BUGS
  2198.         You must not patch this function.
  2199.  
  2200.    SEE ALSO
  2201.         PL_DLPInit(), PL_DLPWriteByte(), PL_DLPWriteLong(),
  2202.         PL_DLPWrite(), PL_DLPTstWrite(), PL_DLPSend(), PL_DLPRead()
  2203.  
  2204.  
  2205. palmlink.library/PL_Explain
  2206.  
  2207.    NAME
  2208.         PL_Explain - Explain an error code
  2209.  
  2210.    SYNOPSIS
  2211.         PL_Explain(Error,Buffer,Length)
  2212.                     A0.l  A1.l   D0.w
  2213.  
  2214.         void PL_Explain(LONG,STRPTR,ULONG);
  2215.  
  2216.    FUNCTION
  2217.         Explains the provided error code. The explanation is copied
  2218.         into the buffer space, until Length is reached.
  2219.  
  2220.         If the error was a DOS error code, it will be explained as
  2221.         well, using dos.library.
  2222.  
  2223.    INPUTS
  2224.         Error         -- (LONG) Error code to be explained
  2225.         Buffer        -- (STRPTR) Buffer for the explanation
  2226.         Length        -- (ULONG) Maximum buffer size, including the
  2227.                 null termination.
  2228.  
  2229.    RESULT
  2230.  
  2231.    NOTE
  2232.  
  2233.    BUGS
  2234.         The error code is provided in A0, not in a data register.
  2235.         Anyhow, for compatibility reasons, this will be kept like that.
  2236.  
  2237.    SEE ALSO
  2238.  
  2239.  
  2240. palmlink.library/PL_FileAddRecord
  2241.  
  2242.    NAME
  2243.         PL_FileAddRecord - add a record to a new file
  2244.  
  2245.    SYNOPSIS
  2246.         Success = PL_FileAddRecord(FileHandle,Buffer,Size,Attr,UID)
  2247.           D0.l                         A0.l    A1.l  D0.l D1.b D2.l
  2248.  
  2249.         int PL_FileAddRecord(APTR,APTR,ULONG,UBYTE,ULONG);
  2250.  
  2251.    FUNCTION
  2252.         Write mode: add a record to the file.
  2253.  
  2254.    INPUTS
  2255.         FileHandle    -- (APTR) Handle of the file
  2256.         Buffer        -- (APTR) Buffer containing the record data.
  2257.                 This buffer will be copied and can be changed after
  2258.                 that.
  2259.         Size          -- (ULONG) Size of the record data.
  2260.         Attr          -- (UBYTE) Record attribute. The attribute consists
  2261.                 of the attribute itself (upper nibble, 0xF0) and the category
  2262.                 ID (lower nibble, 0x0F).
  2263.         UID           -- (ULONG) Record UID. Only the lower 3 bytes are used.
  2264.  
  2265.    RESULT
  2266.         Success       -- (int) TRUE: The new record has been added
  2267.                 successfully.
  2268.  
  2269.    NOTE
  2270.  
  2271.    BUGS
  2272.         Currently, there is no way to find out the reason why this function
  2273.         failed.
  2274.  
  2275.    SEE ALSO
  2276.  
  2277. palmlink.library/PL_FileAddResorce
  2278.  
  2279.    NAME
  2280.         PL_FileAddResource - add a resource to a new file
  2281.  
  2282.    SYNOPSIS
  2283.         Success = PL_FileAddResource(FileHandle,Buffer,Size,Type,ID)
  2284.           D0.l                           A0.l    A1.l  D0.l D1.l D2.w
  2285.  
  2286.         int PL_FileAddResource(APTR,APTR,ULONG,ULONG,UWORD);
  2287.  
  2288.    FUNCTION
  2289.         Write mode: add a resource to the file.
  2290.  
  2291.    INPUTS
  2292.         FileHandle    -- (APTR) Handle of the file
  2293.         Buffer        -- (APTR) Buffer containing the resource data.
  2294.                 This buffer will be copied and can be changed after
  2295.                 that.
  2296.         Size          -- (ULONG) Size of the resource data.
  2297.         Type          -- (ULONG) Resource Type
  2298.         ID            -- (UWORD) Resource ID
  2299.  
  2300.    RESULT
  2301.         Success       -- (int) TRUE: The new resource has been added
  2302.                 successfully.
  2303.  
  2304.    NOTE
  2305.  
  2306.    BUGS
  2307.         Currently, there is no way to find out the reason why this function
  2308.         failed.
  2309.  
  2310.    SEE ALSO
  2311.  
  2312. palmlink.library/PL_FileClose
  2313.  
  2314.    NAME
  2315.         PL_FileClose - close a .prc or .pdb file
  2316.  
  2317.    SYNOPSIS
  2318.         Success = PL_FileClose(FileHandle)
  2319.          D0.l                    A0.l
  2320.  
  2321.         int PL_FileClose(APTR);
  2322.  
  2323.    FUNCTION
  2324.         Close a .prc or .pdb file. If the file was openened for writing,
  2325.         it will be created on close. Thus, if the file couldn't be written,
  2326.         the error will occur here!
  2327.  
  2328.    INPUTS
  2329.         FileHandle    -- (APTR) FileHandle to close.
  2330.  
  2331.    RESULT
  2332.         Success       -- (int) TRUE: File was closed successfully
  2333.  
  2334.    NOTE
  2335.  
  2336.    BUGS
  2337.         Currently, there is no way to find out the reason why this function
  2338.         failed.
  2339.  
  2340.    SEE ALSO
  2341.  
  2342. palmlink.library/PL_FileGetAppInfo
  2343.  
  2344.    NAME
  2345.         PL_FileGetAppInfo - get the application info of this file
  2346.  
  2347.    SYNOPSIS
  2348.         AppInfo = PL_FileGetAppInfo(FileHandle,Size)
  2349.           D0.l                       A0.l      A1.l
  2350.  
  2351.         APTR PL_FileGetAppInfo(APTR,ULONG *);
  2352.  
  2353.    FUNCTION
  2354.         Read mode: Get the application info of the current file.
  2355.  
  2356.    INPUTS
  2357.         FileHandle    -- (APTR) Filehandle of the file
  2358.         Size          -- (ULONG *) The size of the AppInfo is
  2359.                 written into the referenced ULONG.
  2360.  
  2361.    RESULT
  2362.         AppInfo       -- (APTR) Application info of the file.
  2363.                 This structure is READ ONLY!
  2364.  
  2365.    NOTE
  2366.  
  2367.    BUGS
  2368.  
  2369.    SEE ALSO
  2370.  
  2371. palmlink.library/PL_FileGetDBInfo
  2372.  
  2373.    NAME
  2374.         PL_FileGetDBInfo - get the database info of this file
  2375.  
  2376.    SYNOPSIS
  2377.         DBInfo = PL_FileGetDBInfo(FileHandle)
  2378.          D0.l                        A0.l
  2379.  
  2380.         struct DLP_DBInfo *PL_FileGetDBInfo(APTR);
  2381.  
  2382.    FUNCTION
  2383.         Read mode: Get the database info of the current file.
  2384.  
  2385.    INPUTS
  2386.         FileHandle    -- (APTR) Filehandle of the file
  2387.  
  2388.    RESULT
  2389.         DBInfo        -- (struct DLP_DBInfo *) DBInfo of the file.
  2390.                 This structure is READ ONLY!
  2391.  
  2392.    NOTE
  2393.  
  2394.    BUGS
  2395.  
  2396.    SEE ALSO
  2397.  
  2398. palmlink.library/PL_FileGetSortInfo
  2399.  
  2400.    NAME
  2401.         PL_FileGetSortInfo - get the sort info of this file
  2402.  
  2403.    SYNOPSIS
  2404.         SortInfo = PL_FileGetSortInfo(FileHandle,Size)
  2405.           D0.l                         A0.l      A1.l
  2406.  
  2407.         APTR PL_FileGetSortInfo(APTR,ULONG *);
  2408.  
  2409.    FUNCTION
  2410.         Read mode: Get the sort info of the current file.
  2411.  
  2412.    INPUTS
  2413.         FileHandle    -- (APTR) Filehandle of the file
  2414.         Size          -- (ULONG *) The size of the SortInfo is
  2415.                 written into the referenced ULONG.
  2416.  
  2417.    RESULT
  2418.         SortInfo      -- (APTR) Sort info of the file.
  2419.                 This structure is READ ONLY!
  2420.  
  2421.    NOTE
  2422.  
  2423.    BUGS
  2424.  
  2425.    SEE ALSO
  2426.  
  2427. palmlink.library/PL_FileInstall
  2428.  
  2429.    NAME
  2430.         PL_FileInstall - copy a database into the Pilot
  2431.  
  2432.    SYNOPSIS
  2433.         Success = PL_FileInstall(FileHandle,Socket,CardNo)
  2434.          D0.l                       A0.l      A1.l   D0.b
  2435.  
  2436.         int PL_FileInstall(APTR,APTR,UBYTE);
  2437.  
  2438.    FUNCTION
  2439.         Copy a database from this file into the PalmPilot. The database is
  2440.         selected via the current DBInfo.
  2441.  
  2442.    INPUTS
  2443.         FileHandle    -- (APTR) FileHandle
  2444.         Socket        -- (APTR) Socket, connection to the Pilot
  2445.         CardNo        -- (UBYTE) CardNo of the database
  2446.  
  2447.    RESULT
  2448.         Success       -- (int) TRUE: All data have been written successfully
  2449.  
  2450.    NOTE
  2451.         All socket errors can be read using PL_LastError().
  2452.  
  2453.    BUGS
  2454.         Currently, there is no way to find out the reason why this function
  2455.         failed.
  2456.  
  2457.    SEE ALSO
  2458.  
  2459. palmlink.library/PL_FileMerge
  2460.  
  2461.    NAME
  2462.         PL_FileMerge - copy a database into the Pilot, keep old data
  2463.  
  2464.    SYNOPSIS
  2465.         Success = PL_FileMerge(FileHandle,Socket,CardNo)
  2466.          D0.l                    A0.l      A1.l   D0.b
  2467.  
  2468.         int PL_FileMerge(APTR,APTR,UBYTE);
  2469.  
  2470.    FUNCTION
  2471.         Copy a database from this file into the PalmPilot. All old data
  2472.         are kept, so new records are added to existing ones. The database is
  2473.         selected via the current DBInfo.
  2474.  
  2475.    INPUTS
  2476.         FileHandle    -- (APTR) FileHandle
  2477.         Socket        -- (APTR) Socket, connection to the Pilot
  2478.         CardNo        -- (UBYTE) CardNo of the database
  2479.  
  2480.    RESULT
  2481.         Success       -- (int) TRUE: All data have been merged successfully
  2482.  
  2483.    NOTE
  2484.         All socket errors can be read using PL_LastError().
  2485.  
  2486.    BUGS
  2487.         Currently, there is no way to find out the reason why this function
  2488.         failed.
  2489.  
  2490.    SEE ALSO
  2491.  
  2492. palmlink.library/PL_FileOpen
  2493.  
  2494.    NAME
  2495.         PL_FileOpen - open a .prc or .pdb file
  2496.  
  2497.    SYNOPSIS
  2498.         FileHandle = PL_FileOpen(Name,DBInfo)
  2499.           D0.l                   A0.l  A1.l
  2500.  
  2501.         APTR PL_FileOpen(STRPTR,struct DLP_DBInfo *);
  2502.  
  2503.    FUNCTION
  2504.         Open a .prc or .pdb file and grant a database like access to it.
  2505.         The file is opened for reading if no DBInfo is provided (NULL),
  2506.         else it is opened for writing.
  2507.  
  2508.    INPUTS
  2509.         Name          -- (STRPTR) Name of the DOS file
  2510.         DBInfo        -- (struct DLP_DBInfo *) Database info for the
  2511.                 file to write, or NULL for read access.
  2512.  
  2513.    RESULT
  2514.         FileHandle    -- (APTR) Filehandle for this file, or NULL if
  2515.                 an error occured.
  2516.  
  2517.    NOTE
  2518.  
  2519.    BUGS
  2520.         Currently, there is no way to find out the reason why this function
  2521.         failed.
  2522.  
  2523.    SEE ALSO
  2524.  
  2525. palmlink.library/PL_FileReadRecord
  2526.  
  2527.    NAME
  2528.         PL_FileReadRecord - read a record
  2529.  
  2530.    SYNOPSIS
  2531.         Record = PL_FileReadRecord(FileHandle,Index,Size,Attr,UID)
  2532.          D0.l                         A0.l     D0.w A1.l A2.l A3.l
  2533.  
  2534.         APTR PL_FileReadRecord(APTR,UWORD,ULONG *,UBYTE *,ULONG *);
  2535.  
  2536.    FUNCTION
  2537.         Read a record out of the file.
  2538.  
  2539.    INPUTS
  2540.         FileHandle    -- (APTR) Handle of the file
  2541.         Index         -- (UWORD) Index of the record
  2542.         Size          -- (ULONG *) The size of the record is stored into
  2543.                 this ULONG reference.
  2544.         Attr          -- (UBYTE *) The attribute of the record is stored
  2545.                 into this UBYTE reference. The attribute consists of the
  2546.                 attribute itself (upper nibble, 0xF0) and the category
  2547.                 ID (lower nibble, 0x0F).
  2548.         UID           -- (ULONG *) The UID of the record is stored into
  2549.                 this ULONG reference. Only the lower 3 bytes are used.
  2550.  
  2551.    RESULT
  2552.         Record        -- (APTR) Record data. This data is READ ONLY.
  2553.  
  2554.    NOTE
  2555.  
  2556.    BUGS
  2557.         Currently, there is no way to find out the reason why this function
  2558.         failed.
  2559.  
  2560.    SEE ALSO
  2561.  
  2562. palmlink.library/PL_FileReadRecordID
  2563.  
  2564.    NAME
  2565.         PL_FileReadRecordID - read a record by its UID
  2566.  
  2567.    SYNOPSIS
  2568.         Record = PL_FileReadRecordID(FileHandle,UID,Size,Attr,Index)
  2569.          D0.l                         A0.l     D0.l A1.l A2.l A3.l
  2570.  
  2571.         APTR PL_FileReadRecordID(APTR,ULONG,ULONG *,UBYTE *,UWORD *);
  2572.  
  2573.    FUNCTION
  2574.         Read a record out of the file, by its UID.
  2575.  
  2576.    INPUTS
  2577.         FileHandle    -- (APTR) Handle of the file
  2578.         UID           -- (ULONG) The UID of the desired record.
  2579.         Size          -- (ULONG *) The size of the record is stored into
  2580.                 this ULONG reference.
  2581.         Attr          -- (UBYTE *) The attribute of the record is stored
  2582.                 into this UBYTE reference. The attribute consists of the
  2583.                 attribute itself (upper nibble, 0xF0) and the category
  2584.                 ID (lower nibble, 0x0F).
  2585.         Index         -- (UWORD *) The index of the record is stored into
  2586.                 this UWORD reference.
  2587.  
  2588.    RESULT
  2589.         Record        -- (APTR) Record data. This data is READ ONLY.
  2590.  
  2591.    NOTE
  2592.  
  2593.    BUGS
  2594.         Currently, there is no way to find out the reason why this function
  2595.         failed.
  2596.  
  2597.    SEE ALSO
  2598.  
  2599. palmlink.library/PL_FileReadResorce
  2600.  
  2601.    NAME
  2602.         PL_FileReadResource - read a resource
  2603.  
  2604.    SYNOPSIS
  2605.         Resource = PL_FileReadResource(FileHandle,Index,Size,Type,ID)
  2606.           D0.l                            A0.l     D0.w A1.l A2.l A3.l
  2607.  
  2608.         APTR PL_FileReadResource(APTR,UWORD,ULONG *,ULONG *,UWORD *);
  2609.  
  2610.    FUNCTION
  2611.         Read a resource out of the file.
  2612.  
  2613.    INPUTS
  2614.         FileHandle    -- (APTR) Handle of the file
  2615.         Index         -- (UWORD) Index of the resource
  2616.         Size          -- (ULONG *) The size of the resource is stored into
  2617.                 this ULONG reference.
  2618.         Type          -- (ULONG *) The type of the resource is stored into
  2619.                 this ULONG reference.
  2620.         ID            -- (UWORD *) The ID of the resource is stored into
  2621.                 this UWORD reference.
  2622.  
  2623.    RESULT
  2624.         Resource      -- (APTR) Resource data. This data is READ ONLY.
  2625.  
  2626.    NOTE
  2627.  
  2628.    BUGS
  2629.         Currently, there is no way to find out the reason why this function
  2630.         failed.
  2631.  
  2632.    SEE ALSO
  2633.  
  2634. palmlink.library/PL_FileRetrieve
  2635.  
  2636.    NAME
  2637.         PL_FileRetrieve - copy a database into the file
  2638.  
  2639.    SYNOPSIS
  2640.         Success = PL_FileRetrieve(FileHandle,Socket,CardNo)
  2641.          D0.l                       A0.l      A1.l   D0.b
  2642.  
  2643.         int PL_FileRetrieve(APTR,APTR,UBYTE);
  2644.  
  2645.    FUNCTION
  2646.         Copy a database from the PalmPilot to this file. The database is
  2647.         selected via the current DBInfo.
  2648.  
  2649.    INPUTS
  2650.         FileHandle    -- (APTR) FileHandle
  2651.         Socket        -- (APTR) Socket, connection to the Pilot
  2652.         CardNo        -- (UBYTE) CardNo of the database
  2653.  
  2654.    RESULT
  2655.         Success       -- (int) TRUE: All data have been read successfully
  2656.  
  2657.    NOTE
  2658.         All socket errors can be read using PL_LastError().
  2659.  
  2660.    BUGS
  2661.         Currently, there is no way to find out the reason why this function
  2662.         failed.
  2663.  
  2664.    SEE ALSO
  2665.  
  2666. palmlink.library/PL_FileSetAppInfo
  2667.  
  2668.    NAME
  2669.         PL_FileSetAppInfo - set the application info of this file
  2670.  
  2671.    SYNOPSIS
  2672.         Success = PL_FileSetAppInfo(FileHandle,AppInfo,Length)
  2673.          D0.l                         A0.l       A1.l   D0.l
  2674.  
  2675.         int PL_FileSetAppInfo(APTR,APTR,ULONG);
  2676.  
  2677.    FUNCTION
  2678.         Write mode only: Set the application info of the current file.
  2679.  
  2680.    INPUTS
  2681.         FileHandle    -- (APTR) Filehandle of the file
  2682.         AppInfo       -- (APTR) Application info to be set
  2683.         Length        -- (ULONG) Length of the application info
  2684.  
  2685.    RESULT
  2686.         Success       -- (int) TRUE if AppInfo has been set successfully.
  2687.  
  2688.    NOTE
  2689.  
  2690.    BUGS
  2691.         Currently, there is no way to find out the reason why this function
  2692.         failed.
  2693.  
  2694.    SEE ALSO
  2695.  
  2696. palmlink.library/PL_FileSetDBInfo
  2697.  
  2698.    NAME
  2699.         PL_FileSetDBInfo - set the database info of this file
  2700.  
  2701.    SYNOPSIS
  2702.         Success = PL_FileSetDBInfo(FileHandle,DBInfo)
  2703.          D0.l                        A0.l      A1.l
  2704.  
  2705.         int PL_FileSetDBInfo(APTR,struct DLP_DBInfo *);
  2706.  
  2707.    FUNCTION
  2708.         Write mode only: Set the database info of the current file.
  2709.         If the file was openend as resource file, you must also give
  2710.         a resource DBInfo here (record files appropriately).
  2711.  
  2712.    INPUTS
  2713.         FileHandle    -- (APTR) Filehandle of the file
  2714.         DBInfo        -- (struct DLP_DBInfo *) New DBInfo for the file.
  2715.  
  2716.    RESULT
  2717.         Success       -- (int) TRUE if DBInfo has been set successfully.
  2718.  
  2719.    NOTE
  2720.  
  2721.    BUGS
  2722.         Currently, there is no way to find out the reason why this function
  2723.         failed.
  2724.  
  2725.    SEE ALSO
  2726.  
  2727. palmlink.library/PL_FileSetSortInfo
  2728.  
  2729.    NAME
  2730.         PL_FileSetSortInfo - set the sort info of this file
  2731.  
  2732.    SYNOPSIS
  2733.         Success = PL_FileSetSortInfo(FileHandle,SortInfo,Length)
  2734.          D0.l                         A0.l        A1.l    D0.l
  2735.  
  2736.         int PL_FileSetSortInfo(APTR,APTR,ULONG);
  2737.  
  2738.    FUNCTION
  2739.         Write mode only: Set the sort info of the current file.
  2740.  
  2741.    INPUTS
  2742.         FileHandle    -- (APTR) Filehandle of the file
  2743.         SortInfo      -- (APTR) Sort info to be set
  2744.         Length        -- (ULONG) Length of the sort info
  2745.  
  2746.    RESULT
  2747.         Success       -- (int) TRUE if SortInfo has been set successfully.
  2748.  
  2749.    NOTE
  2750.  
  2751.    BUGS
  2752.         Currently, there is no way to find out the reason why this function
  2753.         failed.
  2754.  
  2755.    SEE ALSO
  2756.  
  2757. palmlink.library/PL_FileUsedID
  2758.  
  2759.    NAME
  2760.         PL_FileUsedID - check if a UID is already in use
  2761.  
  2762.    SYNOPSIS
  2763.         Result = PL_FileUsedID(FileHandle,UID)
  2764.          D0.l                    A0.l     D0.l
  2765.  
  2766.         int PL_FileUsedID(APTR,ULONG);
  2767.  
  2768.    FUNCTION
  2769.         Check if a UID is already in use in this file.
  2770.  
  2771.    INPUTS
  2772.         FileHandle    -- (APTR) FileHandle
  2773.         UID           -- (ULONG) UID to be checked
  2774.  
  2775.    RESULT
  2776.         Result        -- (int) TRUE: UID is in use
  2777.  
  2778.    NOTE
  2779.  
  2780.    BUGS
  2781.  
  2782.    SEE ALSO
  2783.  
  2784. palmlink.library/PL_FindRexxHandle
  2785.  
  2786.    NAME
  2787.         PL_FindRexxHandle - Find an ARexx handle
  2788.  
  2789.    SYNOPSIS
  2790.         Socket = PL_FindRexxHandle(Name)
  2791.          D0.l                      A0.l
  2792.  
  2793.         APTR PL_FindRexxHandle(STRPTR);
  2794.  
  2795.    FUNCTION
  2796.         After a socket has been created by an ARexx function, its handle
  2797.         is maintained by the palmlink.library.
  2798.  
  2799.         This function finds the handle name in the internal list and
  2800.         returns the related socket ptr.
  2801.  
  2802.         If the name did not exist, NULL will be returned.
  2803.  
  2804.    INPUTS
  2805.         Name          -- (STRPTR) Name of the handle
  2806.  
  2807.    RESULT
  2808.         Socket        -- The socket that the name was associated with
  2809.  
  2810.    NOTE
  2811.         This function is meant for PalmLink ARexx library programmers.
  2812.         Do not abuse it for other things, please!
  2813.  
  2814.    BUGS
  2815.  
  2816.    SEE ALSO
  2817.         PL_AddRexxHandle(), PL_DeleteRexxHandle()
  2818.  
  2819. palmlink.library/PL_GetBaudRate
  2820.  
  2821.    NAME
  2822.         PL_GetBaudRate - return the negotiated baud rate [V2]
  2823.  
  2824.    SYNOPSIS
  2825.         Rate = PL_GetBaudRate(Socket)
  2826.         D0.l                   A0.l
  2827.  
  2828.         ULONG PL_GetBaudRate(APTR);
  2829.  
  2830.    FUNCTION
  2831.         Return the baud rate that has been negotiated with the Palm.
  2832.         Valid after PL_Accept() or PL_Connect() have been returned.
  2833.         Invalid after PL_CloseSocket() has been invoked.
  2834.  
  2835.    INPUTS
  2836.         Socket        -- (APTR) Socket
  2837.  
  2838.    RESULT
  2839.         Rate          -- (ULONG) Baud rate negotiated with the Palm
  2840.  
  2841.    NOTE
  2842.  
  2843.    BUGS
  2844.  
  2845.    SEE ALSO
  2846.  
  2847. palmlink.library/PL_LastError
  2848.  
  2849.    NAME
  2850.         PL_LastError - return the last error code
  2851.  
  2852.    SYNOPSIS
  2853.         Error = PL_LastError(Socket)
  2854.         D0.l                  A0.l
  2855.  
  2856.         LONG PL_LastError(APTR);
  2857.  
  2858.    FUNCTION
  2859.         Return the code of the last error. Negative codes are PalmLink
  2860.         errors. Positive are DLP error codes. If the error code is
  2861.         PLERR_DOSERROR, you can read dos/IoErr() for the cause.
  2862.  
  2863.    INPUTS
  2864.         Socket        -- (APTR) Socket
  2865.  
  2866.    RESULT
  2867.         Error         -- (LONG) Error code, or PLERR_OKAY if no error
  2868.                          has been occured.
  2869.  
  2870.    NOTE
  2871.  
  2872.    BUGS
  2873.  
  2874.    SEE ALSO
  2875.  
  2876. palmlink.library/PL_OpenSocket
  2877.  
  2878.    NAME
  2879.         PL_OpenSocket - open a socket to a Palm Pilot
  2880.  
  2881.    SYNOPSIS
  2882.         Socket = PL_OpenSocket(TagList)
  2883.         D0.l                    A0.l
  2884.  
  2885.         APTR PL_OpenSocket(struct TagItem *);
  2886.  
  2887.         Socket = PL_OpenSocketTags(Tag1,...)
  2888.  
  2889.         APTR PL_OpenSocketTags(ULONG,...);
  2890.  
  2891.    FUNCTION
  2892.         Open a new socket to a Palm Pilot. The Pilot must be connected to
  2893.         a serial port. As default, the internal serial port is used.
  2894.  
  2895.         If the socket cannot be created, NULL is returned. You can get an
  2896.         explicit error code using the PLTAG_Error tag.
  2897.  
  2898.    INPUTS
  2899.         TagList       -- (struct TagItem *) tags with further options,
  2900.                 or NULL to use all defaults.
  2901.  
  2902.    RESULT
  2903.         Socket        -- (APTR) Pointer to a socket. You must use this
  2904.                 socket for all other functions. NULL if an error occured.
  2905.  
  2906.    TAGS
  2907.         PLTAG_ErrorPtr          -- (LONG *) If an error occured (return code
  2908.                 is NULL), the error code is written into this longword. On
  2909.                 success you will find PLERR_OKAY here.
  2910.  
  2911.         PLTAG_SerialDevice      -- (STRPTR) Name of the serial device to be
  2912.                 used. Defaults to "serial.device". I suggest to use speed
  2913.                 optimized devices, as 8n1.device, to gain maximum transfer
  2914.                 rates between Amiga and Pilot.
  2915.  
  2916.         PLTAG_SerialUnit        -- (LONG) Unit of the serial device. Defaults
  2917.                 to unit 0.
  2918.  
  2919.         PLTAG_SerialMaxRate     -- (ULONG) Maximum baud rate the device can
  2920.                 generate. Defaults to 28800, which is the maximum rate of the
  2921.                 internal serial port common to the Palm Pilot. If you use a
  2922.                 multi serial interface, or faster devices as 8n1.device, you
  2923.                 can go up to 57600.
  2924.  
  2925.         PLTAG_SerialTimeout     -- (ULONG) Time (s) that the serial receiver
  2926.                 waits for a message. If this time passed, a PLERR_TIMEOUT will
  2927.                 be produced. This timeout can also be set to 0, resulting in
  2928.                 that the transfer will not timeout. It is *strongly* suggested
  2929.                 to set a PLTAG_AbortMask then. Otherwise, the user will have
  2930.                 no possibility to abort the transfer progress, e.g. when he
  2931.                 accidentally started it or hardware problems occured.
  2932.                 Defaults to 10.
  2933.  
  2934.         PLTAG_AbortMask         -- (ULONG) Signal mask (*not* signal bit) which
  2935.                 is used to break a serial communication from or to the Palm.
  2936.                 Can be set to e.g. SIGBREAKF_CTRL_C to allow the user to break
  2937.                 a transfer process by CTRL-C. Defaults to 0: no signals will
  2938.                 abort the transfer.
  2939.  
  2940.    NOTE
  2941.  
  2942.    BUGS
  2943.  
  2944.    SEE ALSO
  2945.         PL_CloseSocket()
  2946.  
  2947. palmlink.library/PL_PADPRead
  2948.  
  2949.    NAME
  2950.         PL_PADPRead - read a packet using PADP
  2951.  
  2952.    SYNOPSIS
  2953.         Length = PL_PADPRead(Socket,Buffer,Size)
  2954.         D0.l                  A0.l   A1.l  D0.l
  2955.  
  2956.         LONG PL_PADPRead(APTR,APTR,LONG);
  2957.  
  2958.    FUNCTION
  2959.         Read a data packet from the Palm Pilot, using PADP (Packet
  2960.         Assembly Disassembly Protocol). This function returns the number
  2961.         of bytes that were received, or -1 if an error occured. You can
  2962.         read the error code using PL_LastError().
  2963.  
  2964.         This is a low level call, and is used by the palmlink.library
  2965.         itself. Usually, you do not need to use this function.
  2966.  
  2967.    INPUTS
  2968.         Socket        -- (APTR) Socket
  2969.         Buffer        -- (APTR) Data buffer space
  2970.         Size          -- (LONG) Length of buffer space
  2971.  
  2972.    RESULT
  2973.         Length        -- (LONG) Received bytes, or -1: error
  2974.  
  2975.    NOTE
  2976.  
  2977.    BUGS
  2978.  
  2979.    SEE ALSO
  2980.         PL_PADPWrite()
  2981.  
  2982.  
  2983. palmlink.library/PL_PADPWrite
  2984.  
  2985.    NAME
  2986.         PL_PADPWrite - write a PADP packet to the Palm Pilot
  2987.  
  2988.    SYNOPSIS
  2989.         Length = PL_PADPWrite(Socket,Buffer,Length,Type)
  2990.         D0.l                   A0.l   A1.l   D0.l  D1.w
  2991.  
  2992.         LONG PL_PADPWrite(APTR,APTR,LONG,UWORD);
  2993.  
  2994.    FUNCTION
  2995.         Write a data packet to the Palm Pilot. The packet is sent using
  2996.         the PADP (Packet Assembly Disassembly Protocol). This function
  2997.         returns the number of bytes sent, or -1 if an error occured. You
  2998.         can read the error code using PL_LastError().
  2999.  
  3000.         This is a low level call, and is used by the palmlink.library
  3001.         itself. Usually, you do not need to use this function.
  3002.  
  3003.    INPUTS
  3004.         Socket        -- (APTR) Socket
  3005.         Buffer        -- (APTR) Buffer of data to be transmitted
  3006.         Length        -- (LONG) Number of bytes to send
  3007.         Type          -- (UWORD) Packet type:
  3008.                 PLPADP_DATA     - A plain data packet. This is the most
  3009.                         commonly used packet type.
  3010.                 PLPADP_WAKE     - A wakeup packet. Usually only for
  3011.                         PalmLink internal use.
  3012.                 PLPADP_ACK      - An acknowledge packet. Usually generated
  3013.                         and sent by PalmLink. You don't need to generate
  3014.                         acknowledgements.
  3015.                 PLPADP_TICKLE   - A tickle packet. Used by PL_Tickle().
  3016.                 PLPADP_ABORT    - An abortion packet (PalmOS 2.0 or higher)
  3017.  
  3018.    RESULT
  3019.         Length        -- (LONG) Bytes sent, or -1: error
  3020.  
  3021.    NOTE
  3022.  
  3023.    BUGS
  3024.  
  3025.    SEE ALSO
  3026.         PL_PADPRead()
  3027.  
  3028. palmlink.library/PL_RawRead
  3029.  
  3030.    NAME
  3031.         PL_RawRead - read raw data from the serial interface
  3032.  
  3033.    SYNOPSIS
  3034.         Length = PL_RawRead(Socket,Buffer,Length)
  3035.         D0.l                 A0.l   A1.l   D0.l
  3036.  
  3037.         LONG PL_RawRead(APTR,APTR,LONG);
  3038.  
  3039.    FUNCTION
  3040.         Read raw data from the serial interface, until the buffer is
  3041.         filled or the timeout has been reached. If an error occured,
  3042.         you can use PL_LastError() to find out the cause.
  3043.  
  3044.         This is a low level call, and is used by the palmlink.library
  3045.         itself. Usually, you do not need to use this function.
  3046.  
  3047.    INPUTS
  3048.         Socket        -- (APTR) Socket
  3049.         Buffer        -- (APTR) Data buffer space
  3050.         Length        -- (LONG) Length of buffer space
  3051.  
  3052.    RESULT
  3053.         Length        -- (LONG) Number of bytes read, or 0 if an
  3054.                 error occured.
  3055.  
  3056.    NOTE
  3057.  
  3058.    BUGS
  3059.  
  3060.    SEE ALSO
  3061.         PL_RawWrite(), PL_RawSetBaud()
  3062.  
  3063.  
  3064. palmlink.library/PL_RawSetRate
  3065.  
  3066.    NAME
  3067.         PL_RawSetRate - set the serial interface baud rate
  3068.  
  3069.    SYNOPSIS
  3070.         success = PL_RawSetRate(Socket,Rate)
  3071.         D0.l                     A0.l  D0.l
  3072.  
  3073.         int PL_RawSetRate(APTR,ULONG);
  3074.  
  3075.    FUNCTION
  3076.         Sets the serial interface to the new rate. The default baud
  3077.         rate is 9600 Baud. Other (higher) baud rates are arranged between
  3078.         Amiga and Palm Pilot during initialisation, using CMP.
  3079.  
  3080.         This is a low level call, and is used by the palmlink.library
  3081.         itself. Usually, you do not need to use this function.
  3082.  
  3083.    INPUTS
  3084.         Socket        -- (APTR) Socket
  3085.         Rate          -- (ULONG) New rate in bps.
  3086.  
  3087.    RESULT
  3088.         success       -- (int) TRUE if the rate has been set success-
  3089.                 fully, FALSE on error.
  3090.  
  3091.    NOTE
  3092.  
  3093.    BUGS
  3094.  
  3095.    SEE ALSO
  3096.         PL_RawRead(), PL_RawWrite()
  3097.  
  3098.  
  3099. palmlink.library/PL_RawWrite
  3100.  
  3101.    NAME
  3102.         PL_RawWrite - write raw data to the serial interface
  3103.  
  3104.    SYNOPSIS
  3105.         Length = PL_RawWrite(Socket,Buffer,Length)
  3106.         D0.l                  A0.l   A1.l   D0.l
  3107.  
  3108.         LONG PL_RawWrite(APTR,APTR,LONG);
  3109.  
  3110.    FUNCTION
  3111.         Write raw data to the serial interface. If an error occured,
  3112.         you can use PL_LastError() to find out the cause.
  3113.  
  3114.         This is a low level call, and is used by the palmlink.library
  3115.         itself. Usually, you do not need to use this function.
  3116.  
  3117.    INPUTS
  3118.         Socket        -- (APTR) Socket
  3119.         Buffer        -- (APTR) Data buffer
  3120.         Length        -- (LONG) Length of data
  3121.  
  3122.    RESULT
  3123.         Length        -- (LONG) Number of data that were sent, or
  3124.                 0 if an error occured.
  3125.  
  3126.    NOTE
  3127.  
  3128.    BUGS
  3129.  
  3130.    SEE ALSO
  3131.         PL_RawRead(), PL_RawSetBaud()
  3132.  
  3133.  
  3134. palmlink.library/PL_Read
  3135.  
  3136.    NAME
  3137.         PL_Read - read a packet from the Palm Pilot
  3138.  
  3139.    SYNOPSIS
  3140.         Length = PL_Read(Socket,Buffer,Size)
  3141.         D0.l              A0.l   A1.l  D0.l
  3142.  
  3143.         LONG PL_Read(APTR,UBYTE *,LONG);
  3144.  
  3145.    FUNCTION
  3146.         Read a data packet from the Palm Pilot. DLP packets are received
  3147.         through the PADP layer, and require an established connection. This
  3148.         function returns the number of bytes that were received (i.e. the
  3149.         size of the packet), or -1 if an error occured. You can read the
  3150.         error code using PL_LastError().
  3151.  
  3152.    INPUTS
  3153.         Socket        -- (APTR) Socket
  3154.         Buffer        -- (UBYTE *) Data buffer space
  3155.         Size          -- (LONG) Length of buffer space
  3156.  
  3157.    RESULT
  3158.         Length        -- (LONG) Received bytes, or -1: error
  3159.  
  3160.    NOTE
  3161.         The maximum data packet size is 65536 byte.
  3162.  
  3163.    BUGS
  3164.  
  3165.    SEE ALSO
  3166.         PL_Write()
  3167.  
  3168.  
  3169. palmlink.library/PL_SLPRead
  3170.  
  3171.    NAME
  3172.         PL_SLPRead - read a packet using SLP
  3173.  
  3174.    SYNOPSIS
  3175.         Length = PL_SLPRead(Socket,Buffer,Size,Header,PADP)
  3176.         D0.l                 A0.l   A1.l  D0.l  A2.l  A3.l
  3177.  
  3178.         LONG PL_SLPRead(APTR,APTR,LONG,struct PL_SLP_Header *,struct PL_PADP_Header *);
  3179.  
  3180.    FUNCTION
  3181.         Read a data packet from the Palm Pilot, using SLP (Serial Link
  3182.         Protocol). The SLP header is returned in the space passed in
  3183.         Header. You must provide sufficient space here!
  3184.  
  3185.         Additionally, you may provide space for a PADP header, which will
  3186.         later contain the PADP header of the received packet. This is used
  3187.         by PL_PADPRead and enables to read the packet data directly to the
  3188.         destination instead into a buffer. If there is no PADP header, or
  3189.         if you don't want to read it separately, provide NULL here.
  3190.  
  3191.         This function returns the number of bytes that were received, or
  3192.         -1 if an error occured. You can read the error code using
  3193.         PL_LastError().
  3194.  
  3195.         This is a low level call, and is used by the palmlink.library
  3196.         itself. Usually, you do not need to use this function.
  3197.  
  3198.    INPUTS
  3199.         Socket        -- (APTR) Socket
  3200.         Buffer        -- (APTR) Data buffer space
  3201.         Size          -- (LONG) Length of buffer space
  3202.         Header        -- (struct PL_SLP_Header *) Pointer to a space
  3203.                 that will contain the SLP header hereafter.
  3204.         PADP          -- (struct PL_PADP_Header *) Pointer to a space
  3205.                 for the PADP header, or NULL.
  3206.  
  3207.    RESULT
  3208.         Length        -- (LONG) Received bytes, or -1: error
  3209.                 If a PADP header was provided, its size is not included
  3210.                 in this length.
  3211.  
  3212.    NOTE
  3213.  
  3214.    BUGS
  3215.         If the data buffer is not sufficient, a PLERR_CHECKSUM error will
  3216.         be produced, and the stream must be re-synchronized to the next
  3217.         packet, which could fail. So better make sure that at least 1024
  3218.         byte are available, since this is the maximum packet size that can
  3219.         be transported by SLP.
  3220.  
  3221.    SEE ALSO
  3222.         PL_SLPWrite()
  3223.  
  3224.  
  3225. palmlink.library/PL_SLPWrite
  3226.  
  3227.    NAME
  3228.         PL_SLPWrite - write a SLP packet to the Palm Pilot
  3229.  
  3230.    SYNOPSIS
  3231.         Length = PL_SLPWrite(Socket,Buffer,Length,Header,PADP)
  3232.         D0.l                  A0.l   A1.l   D0.l   A2.l  A3.l
  3233.  
  3234.         LONG PL_SLPWrite(APTR,APTR,LONG,struct PL_SLP_Header *, struct PL_PADP_Header *);
  3235.  
  3236.    FUNCTION
  3237.         Write a data packet to the Palm Pilot. The packet is sent using
  3238.         SLP (Serial Link Protocol). The provided SLP header will be wrapped
  3239.         around the packet. Some parts of the SLP header are generated by
  3240.         this call automatically (see includes).
  3241.  
  3242.         Additionally, you may provide a PADP header, which will be wrapped
  3243.         around the data packet as well. This is used by PL_PADPWrite and
  3244.         allows to send the packet data from the source buffer directly,
  3245.         without the need to copy it into a buffer first. If there is no
  3246.         PADP header, or if you don't want to send it separately, provide
  3247.         NULL here.
  3248.  
  3249.         This function returns the number of sent bytes, or -1 if an error
  3250.         occured. You can read the error code using PL_LastError().
  3251.  
  3252.         This is a low level call, and is used by the palmlink.library
  3253.         itself. Usually, you do not need to use this function.
  3254.  
  3255.    INPUTS
  3256.         Socket        -- (APTR) Socket
  3257.         Buffer        -- (APTR) Buffer of data to be transmitted
  3258.         Length        -- (LONG) Bytes to send. If a PADP header is provided,
  3259.                 do *not* add its size here.
  3260.         Header        -- (struct PL_SLP_Header *) SLP header to be
  3261.                 transmitted. Do not pass NULL here!
  3262.         PADP          -- (struct PL_PADP_Header *) PADP header to be
  3263.                 transmitted, or NULL.
  3264.  
  3265.    RESULT
  3266.         Length        -- (LONG) Bytes sent (PADP header not included),
  3267.                 or -1: error
  3268.  
  3269.    NOTE
  3270.  
  3271.    BUGS
  3272.  
  3273.    SEE ALSO
  3274.         PL_SLPRead()
  3275.  
  3276. palmlink.library/PL_Tickle
  3277.  
  3278.    NAME
  3279.         PL_Tickle - tickle the connection
  3280.  
  3281.    SYNOPSIS
  3282.         success = PL_Tickle(Socket)
  3283.         D0.l                A0.l
  3284.  
  3285.         int PL_Tickle(APTR);
  3286.  
  3287.    FUNCTION
  3288.         Tickles the Palm Pilot connection. I assume this prevents some kind
  3289.         of connection timeout. You will not need this call under normal
  3290.         circumstances.
  3291.  
  3292.    INPUTS
  3293.         Socket        -- (APTR) Socket
  3294.  
  3295.    RESULT
  3296.         success       -- (int) FALSE if an error occured. See PL_LastError()
  3297.                 to get the cause.
  3298.  
  3299.    NOTE
  3300.  
  3301.    BUGS
  3302.  
  3303.    SEE ALSO
  3304.  
  3305.  
  3306. palmlink.library/PL_Write
  3307.  
  3308.    NAME
  3309.         PL_Write - write a packet to the Palm Pilot
  3310.  
  3311.    SYNOPSIS
  3312.         Length = PL_Write(Socket,Buffer,Length)
  3313.         D0.l               A0.l   A1.l   D0.l
  3314.  
  3315.         LONG PL_Write(APTR,UBYTE *,LONG);
  3316.  
  3317.    FUNCTION
  3318.         Write a data packet to the Palm Pilot. DLP packets are sent through
  3319.         the PADP layer. This function returns the number of bytes that were
  3320.         sent, or -1 if an error occured. You can read the error code using
  3321.         PL_LastError().
  3322.  
  3323.    INPUTS
  3324.         Socket        -- (APTR) Socket
  3325.         Buffer        -- (UBYTE *) Buffer of data to be transmitted
  3326.         Length        -- (LONG) Bytes to send
  3327.  
  3328.    RESULT
  3329.         Length        -- (LONG) Bytes sent, or -1: error
  3330.  
  3331.    NOTE
  3332.         The maximum data packet size is 65536 byte.
  3333.  
  3334.    BUGS
  3335.  
  3336.    SEE ALSO
  3337.         PL_Read()
  3338.  
  3339.  
  3340.